_detail::Models::CertificatePolicy CertificatePolicy::ToCertificatePolicy()

in sdk/keyvault/azure-security-keyvault-certificates/src/certificate_client_models.cpp [473:661]

• 183 lines of code
• 58 McCabe index (conditional complexity)

_detail::Models::CertificatePolicy CertificatePolicy::ToCertificatePolicy() const
{
  _detail::Models::CertificatePolicy result;
  if (Enabled.HasValue() || CreatedOn.HasValue() || UpdatedOn.HasValue())
  {
    _detail::Models::CertificateAttributes attributes;
    if (CreatedOn.HasValue())
    {
      attributes.Created = CreatedOn.Value();
    }
    if (Enabled.HasValue())
    {
      attributes.Enabled = Enabled.Value();
    }
    // attributes.Expires = ;
    // attributes.NotBefore = ;
    // attributes.RecoverableDays = ;
    // attributes.RecoveryLevel = ;
    if (UpdatedOn.HasValue())
    {
      attributes.Updated = UpdatedOn.Value();
    }

    result.Attributes = attributes;
  }
  if (IssuerName.HasValue() || CertificateTransparency.HasValue() || CertificateType.HasValue())
  {
    _detail::Models::IssuerParameters issuer;
    if (IssuerName.HasValue())
    {
      issuer.Name = IssuerName.Value();
    }
    if (CertificateTransparency.HasValue())
    {
      issuer.CertificateTransparency = CertificateTransparency.Value();
    }
    if (CertificateType.HasValue())
    {
      issuer.CertificateType = CertificateType.Value();
    }
    result.IssuerParameters = issuer;
  }
  if (Exportable.HasValue() || ReuseKey.HasValue() || KeySize.HasValue() || KeyCurveName.HasValue()
      || KeyType.HasValue())
  {
    _detail::Models::KeyProperties keyProperties;
    if (Exportable.HasValue())
    {
      keyProperties.Exportable = Exportable.Value();
    }
    if (ReuseKey.HasValue())
    {
      keyProperties.ReuseKey = ReuseKey.Value();
    }
    if (KeySize.HasValue())
    {
      keyProperties.KeySize = KeySize.Value();
    }
    if (KeyCurveName.HasValue())
    {
      keyProperties.Curve = _detail::Models::JsonWebKeyCurveName(KeyCurveName.Value().ToString());
    }
    if (KeyType.HasValue())
    {
      keyProperties.KeyType = _detail::Models::JsonWebKeyType(KeyType.Value().ToString());
    }
    result.KeyProperties = keyProperties;
  }
  if (LifetimeActions.size() > 0)
  {
    std::vector<_detail::Models::LifetimeAction> actions;
    for (auto const& item : LifetimeActions)
    {
      _detail::Models::LifetimeAction action;
      if (item.DaysBeforeExpiry.HasValue() || item.LifetimePercentage.HasValue())
      {
        _detail::Models::Trigger trigger;
        if (item.DaysBeforeExpiry.HasValue())
        {
          trigger.DaysBeforeExpiry = item.DaysBeforeExpiry.Value();
        }
        if (item.LifetimePercentage.HasValue())
        {
          trigger.LifetimePercentage = item.LifetimePercentage.Value();
        }
        action.Trigger = trigger;
      }
      _detail::Models::Action actionType;
      actionType.ActionType = _detail::Models::CertificatePolicyAction(item.Action.ToString());
      action.Action = actionType;
      actions.emplace_back(action);
    }
    result.LifetimeActions = actions;
  }
  if (ContentType.HasValue())
  {
    _detail::Models::SecretProperties secretProps;
    secretProps.ContentType = ContentType.Value().ToString();
    result.SecretProperties = secretProps;
  }
  if (Subject.size() > 0 || EnhancedKeyUsage.size() > 0 || KeyUsage.size() > 0
      || SubjectAlternativeNames.Emails.size() > 0 || SubjectAlternativeNames.DnsNames.size() > 0
      || SubjectAlternativeNames.UserPrincipalNames.size() > 0 || ValidityInMonths.HasValue())
  {
    _detail::Models::X509CertificateProperties x509Props;
    if (Subject.size() > 0)
    {
      x509Props.Subject = Subject;
    }
    if (EnhancedKeyUsage.size() > 0)
    {
      std::vector<std::string> keyUsages;
      for (auto const& item : EnhancedKeyUsage)
      {
        keyUsages.emplace_back(item);
      }
      x509Props.Ekus = keyUsages;
    }
    if (KeyUsage.size() > 0)
    {
      std::vector<_detail::Models::KeyUsageType> keyUsages;
      for (auto const& item : KeyUsage)
      {
        if (item == CertificateKeyUsage::DigitalSignature)
        {
          keyUsages.emplace_back(_detail::Models::KeyUsageType(_detail::DigitalSignatureValue));
        }
        else if (item == CertificateKeyUsage::NonRepudiation)
        {
          keyUsages.emplace_back(_detail::Models::KeyUsageType(_detail::NonRepudiationValue));
        }
        else if (item == CertificateKeyUsage::KeyEncipherment)
        {
          keyUsages.emplace_back(_detail::Models::KeyUsageType(_detail::KeyEnciphermentValue));
        }
        else if (item == CertificateKeyUsage::DataEncipherment)
        {
          keyUsages.emplace_back(_detail::Models::KeyUsageType(_detail::DataEnciphermentValue));
        }
        else if (item == CertificateKeyUsage::KeyAgreement)
        {
          keyUsages.emplace_back(_detail::Models::KeyUsageType(_detail::KeyAgreementValue));
        }
        else if (item == CertificateKeyUsage::KeyCertSign)
        {
          keyUsages.emplace_back(_detail::Models::KeyUsageType(_detail::KeyCertSignValue));
        }
        else if (item == CertificateKeyUsage::CrlSign)
        {
          keyUsages.emplace_back(_detail::Models::KeyUsageType(_detail::CrlSignValue));
        }
        else if (item == CertificateKeyUsage::EncipherOnly)
        {
          keyUsages.emplace_back(_detail::Models::KeyUsageType(_detail::EncipherOnlyValue));
        }
        else if (item == CertificateKeyUsage::DecipherOnly)
        {
          keyUsages.emplace_back(_detail::Models::KeyUsageType(_detail::DecipherOnlyValue));
        }
      }
      x509Props.KeyUsage = keyUsages;
    }
    if (SubjectAlternativeNames.Emails.size() > 0 || SubjectAlternativeNames.DnsNames.size() > 0
        || SubjectAlternativeNames.UserPrincipalNames.size() > 0)
    {
      _detail::Models::SubjectAlternativeNames subjectAlternativeNames;

      if (SubjectAlternativeNames.Emails.size() > 0)
      {
        subjectAlternativeNames.Emails = SubjectAlternativeNames.Emails;
      }
      if (SubjectAlternativeNames.DnsNames.size() > 0)
      {
        subjectAlternativeNames.DnsNames = SubjectAlternativeNames.DnsNames;
      }
      if (SubjectAlternativeNames.UserPrincipalNames.size() > 0)
      {
        subjectAlternativeNames.Upns = SubjectAlternativeNames.UserPrincipalNames;
      }
      x509Props.SubjectAlternativeNames = subjectAlternativeNames;
    }
    if (ValidityInMonths.HasValue())
    {
      x509Props.ValidityInMonths = ValidityInMonths.Value();
    }
    result.X509CertificateProperties = x509Props;
  }
  return result;
}