/// <summary>
/// Create EtsNoticeContract from NoticeContract
/// </summary>
/// <param name="dto">Notice data contract</param>
public EtsNoticeContract(NoticeContract dto)
{
Id = dto.Id;
CommunicationInformation = dto.CommunicationInformation;
ComplementaryInformation = dto.ComplementaryInformation;
ConditionsInformation = dto.ConditionsInformation;
ConditionsInformationDefence = dto.ConditionsInformationDefence;
ContactPerson = dto.ContactPerson;
EstimatedValue = dto.ProcurementObject.EstimatedValue;
TotalValue = dto.ProcurementObject.TotalValue;
LotsInfo = dto.LotsInfo;
MainCpvCode = dto.ProcurementObject.MainCpvCode;
ObjectDescriptions = dto.ObjectDescriptions;
NoticeOjsNumber = dto.NoticeOjsNumber;
PreviousNoticeOjsNumber = dto.PreviousNoticeOjsNumber;
Project = new EtsProjectContract
{
Id = dto.Project.Id,
ContractType = dto.Project.ContractType,
ReferenceNumber = dto.Project.ReferenceNumber,
Title = dto.Project.Title,
CentralPurchasing = dto.Project.CentralPurchasing,
DefenceCategory = dto.Project.DefenceCategory,
DisagreeToPublishNoticeBasedOnDefenceServiceCategory4 = dto.Project.DisagreeToPublishNoticeBasedOnDefenceServiceCategory4,
DefenceSupplies = dto.Project.DefenceSupplies,
DefenceWorks = dto.Project.DefenceWorks,
JointProcurement = dto.Project.JointProcurement,
ProcurementCategory = dto.Project.ProcurementCategory,
ProcurementLaw = dto.Project.ProcurementLaw,
AgricultureWorks = dto.Project.AgricultureWorks
};
Organisation = new EtsOrganisationContract
{
Information = dto.Project.Organisation.Information,
ContractingAuthorityType = dto.Project.Organisation.ContractingAuthorityType,
ContractingType = dto.Project.Organisation.ContractingType,
MainActivity = dto.Project.Organisation.MainActivity,
OtherContractingAuthorityType = dto.Project.Organisation.OtherContractingAuthorityType,
OtherMainActivity = dto.Project.Organisation.OtherMainActivity
};
ShortDescription = dto.ProcurementObject.ShortDescription;
TenderingInformation = dto.TenderingInformation;
RewardsAndJury = dto.RewardsAndJury;
ResultsOfContest = dto.ResultsOfContest;
ProcedureInformation = dto.ProcedureInformation;
ProceduresForReview = dto.ProceduresForReview;
Modifications = dto.Modifications;
Type = dto.Type;
LegalBasis = dto.LegalBasis;
Language = dto.Language;
Links = dto.AttachmentInformation.Links;
Defence = dto.ProcurementObject.Defence;
IsCorrigendum = dto.IsCorrigendum;
Changes = dto.Changes;
CorrigendumAdditionalInformation = dto.CorrigendumAdditionalInformation;
ContractAwardsDefence = dto.ContractAwardsDefence;
IsPrivateSmallValueProcurement = dto.IsPrivateSmallValueProcurement;
Annexes = dto.Annexes;
}
private static DateTime?GetExpirationDate(NoticeContract notice, int defaultActiveTimeInMonths)
{
if (notice.TenderingInformation?.TendersOrRequestsToParticipateDueDateTime == null)
{
return(notice.DatePublished?.AddMonths(defaultActiveTimeInMonths));
}
return(notice.TenderingInformation.TendersOrRequestsToParticipateDueDateTime);
}
/// <summary>
/// F03 Contract Award Notice factory constructor.
/// </summary>
/// <param name="notice">The notice</param>
/// <param name="parent">The parent notice</param>
/// <param name="eSenderLogin">The TED esender login</param>
/// <param name="tedContactEmail"></param>
/// <param name="tedSenderOrganisation"></param>
public F20Factory(NoticeContract notice, NoticeContract parent, string eSenderLogin, string tedSenderOrganisation, string tedContactEmail)
{
_notice = notice;
_parent = parent;
_eSenderLogin = eSenderLogin;
_tedContactEmail = tedContactEmail;
_tedSenderOrganisation = tedSenderOrganisation;
}
/// <summary>
/// Legal basis. Used in forms F01-F03
/// </summary>
/// <param name="notice">The notice</param>
/// <param name="parent">Needed if noticetype = modification</param>
/// <returns></returns>
public static List <XElement> LegalBasis(NoticeContract notice, NoticeContract parent = null)
{
string directive = string.IsNullOrEmpty(notice.LegalBasis) ? DirectiveMapper.GetDirective(notice, parent) : notice.LegalBasis;
return(new List <XElement>
{
ElementWithAttribute("LEGAL_BASIS", "VALUE", directive)
});
}
/// <summary>
/// F16 Defence Prior Information factory constructor.
/// </summary>
/// <param name="notice">The notice</param>
/// <param name="eSenderLogin">The TED esender login</param>
/// <param name="tedESenderOrganisation">Organisation that sends notices to eSender api</param>
/// <param name="tedContactEmail">Contact email for technical</param>
/// <param name="translationProvider"></param>
public F16Factory(NoticeContract notice, string eSenderLogin, string tedESenderOrganisation, string tedContactEmail, ITranslationProvider translationProvider)
{
_notice = notice;
_eSenderLogin = eSenderLogin;
_tedContactEmail = tedContactEmail;
_tedESenderOrganisation = tedESenderOrganisation;
_configuration = NoticeConfigurationFactory.CreateConfiguration(notice);
_helper = new SectionHelper(_notice, _configuration, translationProvider);
}
/// <summary>
///
/// </summary>
/// <param name="notice"></param>
/// <param name="eSenderLogin"></param>
/// <param name="tedSenderOrganisation"></param>
/// <param name="tedContactEmail"></param>
/// <returns></returns>
public static XElement LoginPart(NoticeContract notice, string eSenderLogin, string tedSenderOrganisation, string tedContactEmail)
{
return(Element("SENDER",
Element("IDENTIFICATION",
Element("ESENDER_LOGIN", eSenderLogin),
Element("NO_DOC_EXT", notice.NoticeNumber)),
Element("CONTACT", Element("ORGANISATION", tedSenderOrganisation),
Element("COUNTRY", new XAttribute("VALUE", "FI")),
Element("E_MAIL", notice.ContactPerson?.Email ?? tedContactEmail))));
}
/// <summary>
///
/// </summary>
/// <param name="notice"></param>
/// <param name="eSenderLogin"></param>
/// <param name="tedSenderOrganisation"></param>
/// <param name="tedContactEmail"></param>
/// <returns></returns>
public static XElement LoginPart(NoticeContract notice, string eSenderLogin, string tedSenderOrganisation, string tedContactEmail)
{
return(Element("SENDER",
ElementWithAttribute("LOGIN", "CLASS", "B",
Element("ESENDER_LOGIN", eSenderLogin)),
Element("USER",
Element("USER_E_MAILS",
ElementWithAttribute("USER_E_MAIL", "TYPE", "FUNCTIONAL", notice.ContactPerson?.Email ?? tedContactEmail))),
Element("NO_DOC_EXT", notice.NoticeNumber)));
}
/// <summary>
/// Notice factory constructor.
/// </summary>
/// <param name="notice">The notice</param>
/// <param name="parent">The parent notice</param>
/// <param name="tedSenderOrganisationName">Sender organisation name of TED eSender</param>
/// <param name="tedContactEmail">The TED contact email</param>
/// <param name="eSenderLogin">eSenderLogin</param>
/// <param name="translationProvider">Remote translations (Loco)</param>
public TedNoticeFactory(NoticeContract notice, NoticeContract parent, string tedSenderOrganisationName,
string tedContactEmail, string eSenderLogin, ITranslationProvider translationProvider = null)
{
_notice = notice;
_parent = parent;
_tedContactEmail = tedContactEmail;
_tedSenderOrganisation = tedSenderOrganisationName;
_eSenderLogin = eSenderLogin;
_translationProvider = translationProvider;
}
private static double GetEstimatedValue(NoticeContract notice)
{
var estimatedValue = notice.ProcurementObject?.EstimatedValue;
if (estimatedValue?.Value == null || estimatedValue.DisagreeToBePublished == true)
{
return(0);
}
return((double)estimatedValue.Value);
}
public bool ValidateValueFields(NoticeContract notice)
{
bool VerifyDisagreeToPublish(ValueRangeContract value, string path)
{
if ((value?.DisagreeToBePublished ?? false) == false)
{
return(true);
}
_validationErrors.Add($"Value disagreeToBePublished == true for {path} is not valid for notice type {notice.Type}");
return(false);
}
bool VerifyProcurementEstimatedValue(ValueRangeContract estimatedValue, string path)
{
// Only national notices can hide procurement estimated value value
if (notice.Type.IsNational())
{
return(true);
}
return(VerifyDisagreeToPublish(estimatedValue, path));
}
bool VerifyTotalValue(ValueRangeContract totalValue, string path)
{
// Only ContractAwardUtilities can hide total value
if (notice.Type == NoticeType.ContractAwardUtilities)
{
return(true);
}
return(VerifyDisagreeToPublish(totalValue, path));
}
return(ValidateAll(
VerifyProcurementEstimatedValue(notice.ProcurementObject?.EstimatedValue, "notice.EstimatedValue"),
VerifyDisagreeToPublish(notice.ProcurementObject?.Defence?.TotalQuantityOrScope, $"notice.Defence.TotalQuantityOrScope"),
VerifyTotalValue(notice.ProcurementObject?.TotalValue, "notice.TotalValue"),
ValidateAll(notice.ObjectDescriptions.Select((o, ix) => ValidateAll(
VerifyDisagreeToPublish(o.EstimatedValue,
$"notice.ObjectDescriptions[{ix}].EstimatedValue"),
VerifyTotalValue(
o.AwardContract?.AwardedContract?.FinalTotalValue,
$"notice.ObjectDescriptions[{ix}].AwardContract.AwardedContract.FinalTotalValue"))
))));
}
public static Notice Update(this Notice noticeEntity, NoticeContract dto)
{
noticeEntity.Language = dto.Language;
noticeEntity.IsCorrigendum = dto.IsCorrigendum;
noticeEntity.IsCancelled = dto.IsCancelled;
noticeEntity.CancelledReason = dto.CancelledReason;
noticeEntity.ReducedTimeLimitsForReceiptOfTenders = dto.ReducedTimeLimitsForReceiptOfTenders;
noticeEntity.CorrigendumAdditionalInformation = dto.CorrigendumAdditionalInformation;
noticeEntity.IsLatest = dto.IsLatest;
noticeEntity.CommunicationInformation = dto.CommunicationInformation;
noticeEntity.Project = dto.Project;
noticeEntity.ContactPerson = dto.ContactPerson;
noticeEntity.ProcurementObject = dto.ProcurementObject;
noticeEntity.ComplementaryInformation = dto.ComplementaryInformation;
noticeEntity.TedPublishState = dto.TedPublishState;
noticeEntity.ObjectDescriptions = dto.ObjectDescriptions ?? new ObjectDescription[0];
noticeEntity.ConditionsInformation = dto.ConditionsInformation;
noticeEntity.ConditionsInformationDefence = dto.ConditionsInformationDefence;
noticeEntity.ConditionsInformationNational = dto.ConditionsInformationNational;
noticeEntity.ProcedureInformation = dto.ProcedureInformation;
noticeEntity.ProceduresForReview = dto.ProceduresForReview;
noticeEntity.LotsInfo = dto.LotsInfo;
noticeEntity.Modifications = dto.Modifications;
// Might not be ok to let previous submission Id to be changed, might change!
noticeEntity.PreviousNoticeOjsNumber = dto.PreviousNoticeOjsNumber;
noticeEntity.TenderingInformation = dto.TenderingInformation;
noticeEntity.RewardsAndJury = dto.RewardsAndJury;
noticeEntity.AttachmentInformation = dto.AttachmentInformation;
noticeEntity.HasAttachments = noticeEntity.Attachments?.Count > 0 || dto.AttachmentInformation?.Links?.Length > 0;
noticeEntity.ContractAwardsDefence = dto.ContractAwardsDefence;
noticeEntity.ResultsOfContest = dto.ResultsOfContest;
noticeEntity.HilmaStatistics = dto.HilmaStatistics;
noticeEntity.Annexes = dto.Annexes;
noticeEntity.IsPrivateSmallValueProcurement = dto.IsPrivateSmallValueProcurement;
return(noticeEntity);
}
public static string GetDirectiveByProcurementCategory(NoticeContract parent)
{
switch (parent.Project.ProcurementCategory)
{
case ProcurementCategory.Defence:
return(EuDefenceProcurements2009Directive);
case ProcurementCategory.Lisence:
return(EuConcessionProcurement2014Directive);
case ProcurementCategory.Public:
return(EuPublicProcurements2014Directive);
case ProcurementCategory.Utility:
return(EuUtilitiesProcurements2014Directive);
default:
return(EuPublicProcurements2014Directive);
}
}
public static string GetDirective(NoticeContract notice, NoticeContract parent)
{
switch (notice.Type)
{
case NoticeType.PriorInformation:
case NoticeType.PriorInformationReduceTimeLimits:
case NoticeType.Contract:
case NoticeType.ContractAward:
return(notice.Project.Organisation.ContractingAuthorityType == ContractingAuthorityType.MaintypeEu ? EuEuratom2018Directive : EuPublicProcurements2014Directive);
case NoticeType.PeriodicIndicativeUtilities:
case NoticeType.PeriodicIndicativeUtilitiesReduceTimeLimits:
case NoticeType.ContractUtilities:
case NoticeType.ContractAwardUtilities:
case NoticeType.QualificationSystemUtilities:
case NoticeType.SocialUtilities:
case NoticeType.SocialUtilitiesPriorInformation:
case NoticeType.SocialUtilitiesContractAward:
case NoticeType.SocialUtilitiesQualificationSystem:
return(EuUtilitiesProcurements2014Directive);
case NoticeType.DesignContest:
case NoticeType.DesignContestResults:
return(notice.Project.ProcurementCategory == ProcurementCategory.Public ? EuPublicProcurements2014Directive : EuUtilitiesProcurements2014Directive);
case NoticeType.SocialPriorInformation:
case NoticeType.SocialContract:
case NoticeType.SocialContractAward:
return(EuPublicProcurements2014Directive);
case NoticeType.SocialConcessionPriorInformation:
case NoticeType.SocialConcessionAward:
case NoticeType.Concession:
case NoticeType.ConcessionAward:
return(EuConcessionProcurement2014Directive);
case NoticeType.DefenceSimplifiedContract:
case NoticeType.DefenceConcession:
case NoticeType.DefenceContractConcessionnaire:
case NoticeType.DefencePriorInformation:
case NoticeType.DefenceContract:
case NoticeType.DefenceContractAward:
case NoticeType.DefenceContractSub:
return(EuDefenceProcurements2009Directive);
case NoticeType.ExAnte:
if (notice.Project.ProcurementCategory == ProcurementCategory.Defence)
{
return(EuDefenceProcurements2009Directive);
}
else if (notice.Project.ProcurementCategory == ProcurementCategory.Utility)
{
return(EuUtilitiesProcurements2014Directive);
}
else if (notice.Project.ProcurementCategory == ProcurementCategory.Lisence)
{
return(EuConcessionProcurement2014Directive);
}
else if (notice.Project.ProcurementCategory == ProcurementCategory.Public)
{
return(EuPublicProcurements2014Directive);
}
return(null);
case NoticeType.Modification:
if (parent != null && notice.ParentId != null)
{
if (!string.IsNullOrEmpty(parent.LegalBasis))
{
return(parent.LegalBasis);
}
return(GetDirectiveByProcurementCategory(parent));
}
else
{
return(GetDirectiveByProcurementCategory(notice));
}
case NoticeType.BuyerProfile: // Killed with holy fire
case NoticeType.DpsAward:
// Copied from Contract award and contract award utilities based on procurement category
if (notice.Project.ProcurementCategory == ProcurementCategory.Public)
{
return(notice.Project.Organisation.ContractingAuthorityType == ContractingAuthorityType.MaintypeEu
? EuEuratom2018Directive
: EuPublicProcurements2014Directive);
}
else
{
return(EuUtilitiesProcurements2014Directive);
}
default:
return(null);
}
}
/// <summary>
/// Create TED configuration for notice
/// </summary>
/// <param name="notice"></param>
/// <returns></returns>
public static NoticeContractConfiguration CreateConfiguration(NoticeContract notice)
{
switch (notice.Type)
{
case Enums.NoticeType.PriorInformation:
return(PriorNotice);
case Enums.NoticeType.PriorInformationReduceTimeLimits:
return(PriorNoticeReducedTime);
case Enums.NoticeType.PeriodicIndicativeUtilities:
return(PriorNoticeUtilities);
case Enums.NoticeType.PeriodicIndicativeUtilitiesReduceTimeLimits:
return(PriorNoticeReducedTimeUtilities);
case Enums.NoticeType.SocialUtilitiesPriorInformation:
return(PriorNoticeSocialUtilities);
case Enums.NoticeType.Contract:
return(ContractNotice);
case Enums.NoticeType.ContractAward:
return(ContractAward);
case Enums.NoticeType.SocialContract:
return(SocialContract);
case Enums.NoticeType.SocialContractAward:
return(SocialContractAward);
case Enums.NoticeType.DefenceContract:
return(DefenceContractNotice);
case Enums.NoticeType.ContractUtilities:
return(ContractNoticeUtilities);
case Enums.NoticeType.SocialUtilities:
return(SocialUtilities);
case Enums.NoticeType.DefencePriorInformation:
return(DefencePriorInformation);
case Enums.NoticeType.SocialPriorInformation:
return(SocialPriorInformation);
case Enums.NoticeType.ContractAwardUtilities:
return(ContractAwardUtilities);
case Enums.NoticeType.DefenceContractAward:
return(DefenceContractAward);
case Enums.NoticeType.ExAnte:
return(ExAnte(notice));
case Enums.NoticeType.DesignContest:
return(DesignContest);
case Enums.NoticeType.DesignContestResults:
return(DesignContestResults);
case Enums.NoticeType.Concession:
return(Concession);
case Enums.NoticeType.ConcessionAward:
return(ConcessionAward);
case Enums.NoticeType.SocialUtilitiesContractAward:
return(SocialUtilitiesContractAward);
case Enums.NoticeType.DpsAward:
return(notice.Project.ProcurementCategory == Enums.ProcurementCategory.Public ? ContractAward : ContractAwardUtilities);
case Enums.NoticeType.SocialUtilitiesQualificationSystem:
return(SocialUtilitiesQualificationSystem);
case Enums.NoticeType.SocialConcessionPriorInformation:
return(SocialConcessionPriorInformation);
case Enums.NoticeType.SocialConcessionAward:
return(SocialConcessionAward);
default:
break;
}
throw new NotSupportedException($"Notice type {notice.Type} is not supported");
}
private static NoticeContractConfiguration ExAnte(NoticeContract notice) => new NoticeContractConfiguration
{
PreviousNoticeOjsNumber = true, // IV.2
ConditionsInformation = null,
Project = new ProcurementProjectContractConfiguration // ok
{
Title = true, // II.1.1.1
ReferenceNumber = true, // II.1.1.2
ContractType = true, // II.1.3
Organisation = new OrganisationContractConfiguration // I.1
{
Id = true,
ContractingAuthorityType = true,
Information = new ContractBodyContactInformationConfiguration
{
ContactPerson = true,
Department = true,
Email = true,
MainUrl = true,
NationalRegistrationNumber = true,
NutsCodes = true,
OfficialName = true,
PostalAddress = new PostalAddressConfiguration
{
Country = true,
PostalCode = true,
StreetAddress = true,
Town = true
},
TelephoneNumber = true
},
MainActivity = true,
MainActivityUtilities = true,
OtherMainActivity = true,
OtherContractingAuthorityType = true
}
},
LotsInfo = new LotsInfoConfiguration // Ok
{
DivisionLots = true,
QuantityOfLots = true,
// Does F15 does not have these additional fields
// LotCombinationPossible = false,
// LotCombinationPossibleDescription = false
},
ObjectDescriptions = new ObjectDescriptionConfiguration()
{
Title = true, // II.2.1.1
LotNumber = true, // II.2.1.2
AdditionalCpvCodes = new CpvCodeConfiguration // II.2.2
{
Code = true, VocCodes = new VocCodeConfiguration {
Code = true
}
},
NutsCodes = true, // II.2.3.1
MainsiteplaceWorksDelivery = true, // II.2.3.2
DescrProcurement = true, // II.2.4.1
DisagreeAwardCriteriaToBePublished = true, // II.2.5.1
AwardCriteria = new AwardCriteriaConfiguration // II.2.5
{
CriterionTypes = true,
QualityCriteria = new AwardCriterionDefinitionConfiguration {
Criterion = true, Weighting = true
},
CostCriteria = new AwardCriterionDefinitionConfiguration {
Criterion = true, Weighting = true
},
PriceCriterion = new AwardCriterionDefinitionConfiguration {
Weighting = true
},
Criterion = true
},
AdditionalInformation = true, // II.2.14
EuFunds = new EuFundsConfiguration // II.2.13
{
ProcurementRelatedToEuProgram = true,
ProjectIdentification = true
},
OptionsAndVariants = new OptionsAndVariantsConfiguration // II.2.11
{
Options = true,
OptionsDescription = true
},
AwardContract = new AwardConfiguration
{
ContractAwarded = true,
AwardedContract = new ContractAwardConfiguration
{
ContractTitle = true,
ConclusionDate = true, // V.2.1
DisagreeContractorInformationToBePublished = true, // V.2.3.1
Contractors = new ContractorContactInformationConfiguration // V.2.3
{
OfficialName = true,
NationalRegistrationNumber = true,
NutsCodes = true,
PostalAddress = new PostalAddressConfiguration
{
StreetAddress = true,
PostalCode = true,
Town = true,
Country = true
},
TelephoneNumber = true,
Email = true,
MainUrl = true,
IsSmallMediumEnterprise = true
},
FinalTotalValue = new ValueRangeContractConfiguration // V.2.4
{
DisagreeToBePublished = true,
Value = true,
Currency = true,
MinValue = true,
MaxValue = true
},
LikelyToBeSubcontracted = true, // V.2.5.1
ValueOfSubcontract = new ValueContractConfiguration // V.2.5.2-3
{
Value = true,
Currency = true
},
ProportionOfValue = true, // V.2.5.4
SubcontractingDescription = true, // V.2.5.5
ExAnteSubcontracting = notice.Project.ProcurementCategory == ProcurementCategory.Defence ? new ExAnteSubcontractingConfiguration // V.2.5
{
AllOrCertainSubcontractsWillBeAwarded = true,
ShareOfContractWillBeSubcontracted = true,
ShareOfContractWillBeSubcontractedMaxPercentage = true,
ShareOfContractWillBeSubcontractedMinPercentage = true,
} : null
},
}
},
ContactPerson = new ContactPersonConfiguration // ? Part of organisation i guess
{
Name = true,
Email = true,
Phone = true
},
ProcurementObject = new ProcurementObjectConfiguration
{
ShortDescription = true, // II.1.4
TotalValue = new ValueRangeContractConfiguration
{ // II.1.7
Currency = true,
Value = true,
DisagreeToBePublished = true,
Type = true,
MaxValue = true,
MinValue = true
},
MainCpvCode = new CpvCodeConfiguration // II.1.2
{
Code = true, VocCodes = new VocCodeConfiguration {
Code = true
}
},
},
ComplementaryInformation = new ComplementaryInformationConfiguration // VI.3.1
{
AdditionalInformation = true,
},
ProcedureInformation = new ProcedureInformationConfiguration
{
ProcedureType = true, // IV.1.1
ProcurementGovernedByGPA = true, // IV.1.8
FrameworkAgreement = new FrameworkAgreementInformationConfiguration // IV.1.3
{
IncludesFrameworkAgreement = true,
}
},
ProceduresForReview = new ProceduresForReviewInformationConfiguration // VI.4
{
ReviewBody = ContractBodyContactInformationConfigurationDefault,
ReviewProcedure = true
},
Annexes = new AnnexConfiguration
{
D1 = new AnnexD1Configuration
{
NoTenders = true,
SuppliesManufacturedForResearch = true,
ProvidedByOnlyParticularOperator = true,
ExtremeUrgency = true,
AdditionalDeliveries = true,
RepetitionExisting = true,
DesignContestAward = true,
CommodityMarket = true,
AdvantageousTerms = true
}
}
};
/// <summary>
/// Create EtsNoticeContract from NoticeContract
/// </summary>
/// <param name="dto">Notice data contract</param>
public EtsNoticeContract(NoticeContract dto)
{
Id = dto.Id;
CommunicationInformation = dto.CommunicationInformation;
ComplementaryInformation = dto.ComplementaryInformation;
ConditionsInformation = dto.ConditionsInformation;
ConditionsInformationDefence = dto.ConditionsInformationDefence;
ContactPerson = dto.ContactPerson;
EstimatedValue = dto.ProcurementObject.EstimatedValue;
TotalValue = dto.ProcurementObject.TotalValue;
LotsInfo = dto.LotsInfo;
MainCpvCode = dto.ProcurementObject.MainCpvCode;
ObjectDescriptions = dto.ObjectDescriptions;
NoticeOjsNumber = dto.NoticeOjsNumber;
PreviousNoticeOjsNumber = dto.PreviousNoticeOjsNumber;
Project = new EtsProjectContract
{
Id = dto.Project.Id,
ContractType = dto.Project.ContractType,
ReferenceNumber = dto.Project.ReferenceNumber,
Title = dto.Project.Title,
CentralPurchasing = dto.Project.CentralPurchasing,
DefenceCategory = dto.Project.DefenceCategory,
DisagreeToPublishNoticeBasedOnDefenceServiceCategory4 = dto.Project.DisagreeToPublishNoticeBasedOnDefenceServiceCategory4,
DefenceSupplies = dto.Project.DefenceSupplies,
DefenceWorks = dto.Project.DefenceWorks,
JointProcurement = dto.Project.JointProcurement,
ProcurementCategory = dto.Project.ProcurementCategory,
ProcurementLaw = dto.Project.ProcurementLaw,
AgricultureWorks = dto.Project.AgricultureWorks,
CoPurchasers = dto.Project.CoPurchasers
};
Organisation = new EtsOrganisationContract
{
Information = dto.Project.Organisation.Information,
ContractingAuthorityType = dto.Project.Organisation.ContractingAuthorityType,
ContractingType = dto.Project.Organisation.ContractingType,
MainActivity = dto.Project.Organisation.MainActivity,
OtherContractingAuthorityType = dto.Project.Organisation.OtherContractingAuthorityType,
OtherMainActivity = dto.Project.Organisation.OtherMainActivity,
MainActivityUtilities = dto.Project.Organisation.MainActivityUtilities
};
ShortDescription = dto.ProcurementObject.ShortDescription;
TenderingInformation = dto.TenderingInformation;
RewardsAndJury = dto.RewardsAndJury;
ResultsOfContest = dto.ResultsOfContest;
ProcedureInformation = dto.ProcedureInformation;
ProceduresForReview = dto.ProceduresForReview;
Modifications = dto.Modifications;
Type = dto.Type;
LegalBasis = dto.LegalBasis;
Language = dto.Language;
Links = dto.AttachmentInformation.Links;
Defence = dto.ProcurementObject.Defence;
IsCorrigendum = dto.IsCorrigendum;
IsCancelled = dto.IsCancelled;
CancelledReason = dto.CancelledReason;
Changes = dto.Changes;
CorrigendumAdditionalInformation = dto.CorrigendumAdditionalInformation;
ContractAwardsDefence = dto.ContractAwardsDefence;
IsPrivateSmallValueProcurement = dto.IsPrivateSmallValueProcurement;
Annexes = dto.Annexes;
if (dto.HilmaStatistics != null)
{
HilmaStatistics = new HilmaStatistics
{
EnergyEfficiencyConsidered = dto.HilmaStatistics.EnergyEfficiencyConsidered,
InnovationConsidered = dto.HilmaStatistics.InnovationConsidered,
SMEParticipationConsidered = dto.HilmaStatistics.SMEParticipationConsidered,
LowCarbon = dto.HilmaStatistics.LowCarbon,
CircularEconomy = dto.HilmaStatistics.CircularEconomy,
Biodiversity = dto.HilmaStatistics.Biodiversity,
SustainableFoodProduction = dto.HilmaStatistics.SustainableFoodProduction,
ListedGreenCriteriaUsed = dto.HilmaStatistics.ListedGreenCriteriaUsed,
JustWorkingConditions = dto.HilmaStatistics.JustWorkingConditions,
EmploymentCondition = dto.HilmaStatistics.EmploymentCondition,
HowManyOpportunitiesIsEstimated = dto.HilmaStatistics.HowManyOpportunitiesIsEstimated,
CodeOfConduct = dto.HilmaStatistics.CodeOfConduct,
SolutionNewToBuyer = dto.HilmaStatistics.SolutionNewToBuyer,
SolutionNewToMarketOrIndustry = dto.HilmaStatistics.SolutionNewToMarketOrIndustry,
EndUserInvolved = dto.HilmaStatistics.EndUserInvolved
}
}
;
}
/// <summary>
/// 2019-000000-000 vuosi-id-lot
/// </summary>
/// <param name="notice">Notice conrtact</param>
/// <param name="lotNumber">lot number</param>
/// <returns></returns>
public static string GetContractNumber(NoticeContract notice, int lotNumber)
{
return($"{DateTime.Now.Year}-{(notice.Id % 1000000):D6}-{(lotNumber % 1000):D3}");
}
/// <summary>
/// Public constructor that sets the notice and configuration.
/// </summary>
/// <param name="notice"></param>
/// <param name="configuration"></param>
public AnnexHelper(NoticeContract notice, AnnexConfiguration configuration)
{
_notice = notice;
_configuration = configuration;
}
