How SAM Entitlement Import Resolves Publisher Part Numbers, Product Definitions, and Software ModelsSummary<!-- /*NS Branding Styles*/ --> .ns-kb-css-body-editor-container { p { font-size: 12pt; font-family: Lato; color: var(--now-color--text-primary, #000000); } span { font-size: 12pt; font-family: Lato; color: var(--now-color--text-primary, #000000); } h2 { font-size: 24pt; font-family: Lato; color: var(--now-color--text-primary, black); } h3 { font-size: 18pt; font-family: Lato; color: var(--now-color--text-primary, black); } h4 { font-size: 14pt; font-family: Lato; color: var(--now-color--text-primary, black); } a { font-size: 12pt; font-family: Lato; color: var(--now-color--link-primary, #00718F); } a:hover { font-size: 12pt; color: var(--now-color--link-primary, #024F69); } a:target { font-size: 12pt; color: var(--now-color--link-primary, #032D42); } a:visited { font-size: 12pt; color: var(--now-color--link-primary, #00718f); } ul { font-size: 12pt; font-family: Lato; } li { font-size: 12pt; font-family: Lato; } img { display: ; max-width: ; width: ; height: ; } } Software entitlement import in Software Asset Management (SAM) does more than copy spreadsheet values into alm_license. SAM uses Publisher Part Number (PPN), Content Service product definitions, publisher/product information, software-model attributes, and Discovery Map information to determine which software model should represent the purchased rights. The high-level flow is: Excel entitlement row → Entitlement import → Publisher Part Number/Product Definition lookup → Existing software-model resolution or software-model creation → Metric/entitlement validation → alm_license creation → Import result/error tracking. The most important concept is: PPN identifies the purchased product definition; the software model represents the licensable product/version/edition/platform/language conditions; the entitlement stores the purchased rights against that software model. 1. The main backend objects Bulk entitlement import starts from an import record in samp_bulk_import. Row-level entitlement import/error information is surfaced through samp_entitlement_import. Successful software entitlements are stored in alm_license. Software Product Definitions containing PPN content are stored in samp_sw_product_definition. Software products are stored in samp_sw_product. Discovery Maps are stored in samp_sw_entitlement_definition. Software models are stored in cmdb_software_product_model. Current Software Asset Workspace reporting can relate created entitlements back to imports through samp_m2m_alm_license_import. These objects represent different parts of the process and should not be treated as one import table. 2. What a Publisher Part Number represents A Publisher Part Number identifies a publisher's commercial purchasable software offering. In SAM Content Service, Software PPN content is represented through Software Product Definitions in samp_sw_product_definition. A PPN can carry the context needed to identify the relevant publisher, product, version, edition, platform, language, licensing program information, and the Discovery Map/software-model structure associated with the purchased software. This makes the PPN one of the strongest inputs for resolving an entitlement to the correct software model. 3. Product Definition is not the same as Software Model A Software Product Definition in samp_sw_product_definition represents Content Service PPN/product information. A software model in cmdb_software_product_model represents the licensable model used to connect purchased rights with discovered software usage. An entitlement in alm_license references the software model against which the purchased rights are reconciled. Conceptually: PPN/Product Definition identifies what was purchased → Software Model defines what software that purchase can license → Entitlement stores how many rights were purchased. 4. Product Definition and Discovery Map are different objects Software Product Definitions are stored in samp_sw_product_definition. Discovery Maps are stored in samp_sw_entitlement_definition. A Discovery Map provides the software-content mapping used to relate normalized discovery information to licensable software definitions. These tables should not be confused even though Content Service can use both while resolving software models and PPNs. A useful distinction is: samp_sw_product_definition = PPN/product content; samp_sw_entitlement_definition = Discovery Map content. 5. Starting a bulk entitlement import In Software Asset Workspace, selecting the import option from Create entitlement opens a new samp_bulk_import record. The user uploads the entitlement spreadsheet, and the import record retains the upload/import history. This is why samp_bulk_import should be treated as the import job/header record rather than the final entitlement itself. The final purchased-right records are created in alm_license. 6. The import template contributes to software-model resolution The entitlement spreadsheet can contain fields such as Publisher Part Number, Publisher, Product, Version, Edition, Platform, and Language. The Install condition name can also be considered when identifying the correct software model during import. These values are important because more than one software model can exist for the same product. Example: Product X 2025 Enterprise on Windows can legitimately require a different cmdb_software_product_model from Product X 2025 Standard on Linux. 7. PPN is the preferred content-driven resolution path When a PPN is supplied, SAM matches it against PPN information in the Content Service Library. The corresponding software product definition provides the content context used to identify the software model associated with that purchased offering. If an existing software model is already linked to the PPN/product definition, the entitlement can be associated with that model instead of creating another software model. The preferred flow is therefore: PPN → Content Service Product Definition → Existing Software Model → Entitlement. 8. Existing software model for the PPN If SAM finds an existing software model for the selected PPN, the Software model is automatically populated. The system does not need to create another cmdb_software_product_model simply because another entitlement for the same PPN is being imported. This reuse is important because multiple entitlement purchases can legitimately point to the same software model while carrying different quantities, contracts, agreement types, companies, dates, or costs. 9. PPN can trigger software-model creation If the PPN identifies supported Content Service information but the required software model does not yet exist, SAM can automatically create the software model. This is the same general behavior used when creating entitlements interactively: specifying a PPN can create the necessary software model or link the entitlement to an existing one. Therefore, administrators do not normally need to manually pre-create every software model before importing content-backed entitlements. 10. PPN can cause related underlying models to be created A PPN-backed model can participate in suite relationships, downgrade rights, or next-version relationships. When resolving the PPN, SAM can determine that additional underlying software models are required for those relationships. The entitlement error form can warn when a large number of underlying software models may be created, particularly when required models for suite components, downgrade rights, or next-version relationships do not already exist. This is why importing one entitlement can sometimes result in more software-model activity than expected. 11. Missing PPN does not automatically prevent import A PPN is the preferred Content Service path, but it is not mandatory for every entitlement import. When the spreadsheet has no PPN or an invalid PPN but contains valid Publisher and Product values, SAM can automatically create a software model for the entitlement. For this fallback path, the automatically created software model is stamped with source type: entitlement_import. The key condition is: PPN empty/invalid + valid Publisher + valid Product → automatic software-model creation can occur. 12. Property controlling fallback software-model creation Automatic software-model creation during entitlement import is controlled by com.snc.samp.smcreation_on_entitlement_import. When the property permits automatic creation, an import row with missing/invalid PPN but valid Publisher and Product can result in a new software model. Setting com.snc.samp.smcreation_on_entitlement_import = false disables this automatic software-model creation behavior. This property is important when two instances behave differently for the same PPN-less import file. 13. Source type for models created by fallback import When the software model is automatically created from entitlement import because the PPN is missing or invalid while Publisher and Product are valid, the software model is stamped with source type entitlement_import. This provides a useful backend distinction between models created through entitlement-import fallback and models established through other sources/content paths. When investigating unexpected automatically created software models, check their source information together with the originating entitlement import. 14. Publisher and Product remain important even when PPN is used PPN resolution is not independent of Publisher and Product. The Software Model field can display a warning if the selected PPN is not associated with the Publisher and Product of the selected software model. The administrator can then correct the model or explicitly continue with the current entitlement configuration. Therefore: PPN, Publisher, Product, and Software Model are related validation dimensions; the presence of a PPN should not be interpreted as permission to ignore mismatched product information. 15. Conflicting or missing PPN can be corrected from existing product-definition content If an entitlement-import spreadsheet contains a conflicting or missing PPN and an existing Product Definition provides the appropriate PPN, SAM can set the PPN to the existing product-definition value when available. This helps keep the entitlement aligned to known Content Service product information rather than preserving an unnecessary conflicting purchase identifier. The behavior depends on applicable Product Definition content being available. 16. Publisher Part Number not found If the imported PPN cannot be found in the normal content path, the import can produce a Publisher Part Number not found error. This does not always mean the publisher/product information is unusable. If the entitlement's Publisher, Product, Version, Edition, Platform, and Language resolve to a Discovery Map, the import error can be manually reviewed and a custom PPN can be created for that relationship. This provides a supported path for valid customer purchase part numbers that are not already represented in the standard Content Service PPN library. 17. Custom PPN requires a Discovery Map relationship When a PPN is not present in Content Service but a suitable Discovery Map exists, SAM can create a custom Publisher Part Number after the import error is reviewed and corrected. If no Discovery Map exists, the required Discovery Map must first be created/associated before the PPN can be connected to the software definition. The relationship is therefore: unknown PPN → identify matching Discovery Map → create/associate custom PPN → resolve software model/entitlement. 18. Why Discovery Maps matter Discovery Maps are stored in samp_sw_entitlement_definition. They describe software-content conditions used to connect normalized discovery information with licensable software definitions. Version, Edition, Platform, and Language are therefore not merely descriptive spreadsheet columns; they can materially affect which Discovery Map and software model represent the purchased entitlement. A wrong model can later make reconciliation fail even when entitlement quantity is correct. 19. Multiple software models can match similar content SAM can encounter more than one software model with the same or equivalent Discovery Map conditions. When this occurs, the system cannot safely assume which existing software model represents the purchase. The Software Model must then be selected manually. This is an important safeguard because silently choosing one of several indistinguishable models could attach purchased rights to the wrong licensing definition. 20. PPN does not mean there can only be one software model The same commercial content can result in multiple software models in an instance because models can differ by conditions, licensing use, customer configuration, install conditions, or previous model creation. Therefore, PPN resolution can automatically populate the model only when there is a sufficiently deterministic match. When multiple matching models exist, manual selection is required rather than simply taking the first record. 21. Publisher, Product, Version, Edition, Platform, and Language define licensing identity When PPN resolution is unavailable or incomplete, the import relies more heavily on the software identity supplied by the row. Publisher and Product identify the software family; Version and Edition narrow the licensing scope; Platform and Language can further distinguish the software model. These values are later used to connect discovered normalized software with the entitlement's software model. A software model should therefore represent the purchased licensing rights, not merely copy a convenient display name from the spreadsheet. 22. Install condition can participate in model matching The entitlement import supports Install condition name as another value considered while finding the correct software model. This matters when two models otherwise describe the same Publisher/Product/Version/Edition/Platform/Language but differ in the installations they are intended to cover. Therefore, an install-condition difference can legitimately require a different cmdb_software_product_model. 23. Software model drives Metric Group After a software model is identified, Metric Group is populated based on the Software Model. The Metric Group controls which license metrics are appropriate for that publisher/licensing family. The available License Metric choices then depend on the Metric Group. The downstream relationship is: Software Model → Metric Group → available License Metrics → reconciliation calculation. This is why software-model resolution is not simply a reporting convenience; it determines how purchased rights can later be reconciled. 24. License Metric is not inferred only from PPN text The PPN helps resolve the commercial/software definition, but the entitlement must still have a valid licensing metric. alm_license.license_metric determines how the purchased rights are counted during reconciliation. Examples include Per Device, Per User, Per Core, User Subscription, publisher-specific metrics, and other supported calculations. A correctly resolved PPN with an incorrect license metric can still produce an incorrect compliance result. 25. Agreement Type can also be enriched from PPN-driven entitlement creation When entitlement creation is driven by a recognized Publisher Part Number, SAM can populate additional licensing information such as Software Model, Metric Group, Agreement Type, and software lifecycle information where available. Agreement Type is important because it can influence other licensing behavior such as automatic downgrade-right generation. PPN resolution therefore connects the commercial purchase identifier to more than just the software-model display name. 26. Successful import creates the entitlement in alm_license After the import row is successfully resolved and validated, the purchased-right record is created as a Software Entitlement in alm_license. Important entitlement fields then include software_model, license_metric, Publisher Part Number, purchased rights, license type, agreement type, dates, contract information, and other licensing/financial fields supplied by the import. From reconciliation's perspective, alm_license.software_model is particularly important because it connects the purchased rights to the licensable software definition. 27. Import header/history remains in samp_bulk_import The completion of the entitlement does not remove the original import history. samp_bulk_import retains the import record so administrators can review the uploaded file and its processing status later. Software Asset Workspace also uses samp_bulk_import when presenting successful, completed-with-errors, or failed entitlement-import activity. This gives administrators an import-level history independent of the final entitlement records. 28. Row-level import errors are surfaced through samp_entitlement_import When an entitlement row requires review, Software Asset Workspace surfaces the problem through samp_entitlement_import. The error record provides the reason the entitlement could not be successfully created and exposes fields used to correct the row, including Publisher Part Number, Publisher, Product, Software Model, Metric Group, License Metric, and other entitlement information. Current Workspace logic queries open errors using error_status = open. Therefore, an import can complete at the file level while individual entitlement rows still require correction. 29. Error status reflects manual correction An entitlement-import error can move from a needs-review/open condition to a corrected state after the required values are fixed and the entitlement is successfully created. When an error row has valid Publisher and Product but no software model, importing the corrected record can trigger the supported automatic software-model creation behavior when that behavior is enabled. The important point is that fixing the error is not simply clearing an error flag; SAM must successfully create a valid entitlement/model relationship. 30. Successful created-entitlement/import relationships Current Software Asset Workspace reporting uses samp_m2m_alm_license_import to relate created alm_license records with their import records for import processing/reporting. This table is useful when determining which entitlements were created from a particular automated/assisted entitlement-import process. It should not be confused with samp_entitlement_import, which represents import rows/errors requiring review, or samp_bulk_import, which represents the overall import. 31. Current Workspace import data map A useful backend map is: Import file/job = samp_bulk_import; row/error review = samp_entitlement_import; created entitlement = alm_license; created-entitlement/import relationship = samp_m2m_alm_license_import; PPN/Product Definition = samp_sw_product_definition; Discovery Map = samp_sw_entitlement_definition; software model = cmdb_software_product_model. This separation is useful when an administrator says "the entitlement import is wrong" because the actual problem may belong to the file, row, content definition, model resolution, or final entitlement. 32. Example: valid PPN and existing software model Spreadsheet row contains a valid Microsoft PPN. The PPN matches a Software Product Definition in samp_sw_product_definition. A suitable cmdb_software_product_model already exists for that content. SAM links/populates that software model and creates the entitlement in alm_license against the existing model. No duplicate software model is required. 33. Example: valid PPN but software model does not exist The imported PPN exists in Content Service and identifies a supported product definition, but the corresponding software model has not yet been created in the instance. SAM can automatically create the required cmdb_software_product_model and associate the entitlement with it. Related suite component, downgrade, or next-version model creation may also occur when the PPN's content relationships require those models. 34. Example: PPN is blank but Publisher and Product are valid The spreadsheet contains Publisher = Vendor A and Product = Product X, but Publisher Part Number is empty. If Publisher and Product are valid and com.snc.samp.smcreation_on_entitlement_import permits automatic model creation, SAM can create a new software model and stamp its source type as entitlement_import. The entitlement can then be created against that generated model. This is the fallback model-creation path rather than the Content Service PPN path. 35. Example: PPN is invalid but Publisher and Product are valid The PPN supplied in the file does not resolve to valid PPN content, but Publisher and Product are recognized. With automatic entitlement-import model creation enabled, the Publisher/Product values can still allow a software model to be created. This prevents every unknown PPN from blocking the entire import, while still preserving PPN-not-found handling where a specific custom PPN relationship must be created. 36. Example: PPN not found but Discovery Map exists The imported PPN is not in the Content Service PPN library. Publisher/Product/Version/Edition/Platform/Language resolve to an existing Discovery Map. The import record can be reviewed and corrected, allowing a custom Publisher Part Number to be created and associated with that Discovery Map. That custom content can then support the entitlement/software-model relationship. 37. Example: PPN not found and no Discovery Map exists The imported PPN is unknown and no matching Discovery Map exists. SAM cannot use a Discovery Map association that does not exist. The required software content relationship must first be defined so the custom PPN can be associated appropriately. This is different from merely increasing entitlement quantity or changing the import status. 38. Example: multiple matching software models exist A PPN resolves to content whose Discovery Map conditions correspond to multiple existing software models. Automatically taking the first model would be ambiguous. SAM therefore requires the Software Model to be selected manually. The administrator should compare the existing models' Product, Version, Edition, Platform, Language, install conditions, and intended licensing use before selecting one. 39. Example: PPN and software model disagree The selected PPN belongs to Product X, but the Software Model points to Product Y. SAM can display a warning that the PPN is not associated with the Publisher/Product represented by the selected model. The correct action is to validate whether the PPN or Software Model is wrong rather than ignoring the mismatch simply because an entitlement record can technically be saved. A mismatched model can later prevent the entitlement from applying to the intended installations. 40. Why incorrect software-model resolution affects reconciliation Reconciliation evaluates alm_license through its software model. If the entitlement import resolves to the wrong cmdb_software_product_model, SAM can subsequently compare the purchased rights against the wrong product, version, edition, platform, suite/downgrade relationship, or install condition. This can produce symptoms such as No Entitlements, unexpected unlicensed software, unused purchased rights, or rights being applied to the wrong usage. Therefore, entitlement import quality directly affects reconciliation quality. 41. PPN should not be treated as an arbitrary customer identifier Publisher Part Number has a specific licensing/content purpose. It should not be populated with an unrelated internal SKU or purchase-order identifier merely to satisfy the import field. A recognized PPN is used to connect the entitlement with Content Service Product Definition data and the corresponding software-model relationships. Internal purchasing identifiers belong in their appropriate purchasing/contract fields rather than replacing the publisher's PPN. 42. Product Definition content can change over time Content Service can deliver new or updated Software Product Definitions. Software Asset Workspace exposes new PPN activity through Software Product Definitions in samp_sw_product_definition. This means the set of recognized PPNs can evolve with Content Service updates. When a previously unsupported publisher part number becomes available through content, later entitlement creation/import can use that standard definition rather than requiring a custom one. 43. Software Product Definitions are available in Content lookup The Content lookup portal exposes Software PPN content from samp_sw_product_definition. It also exposes Software Products from samp_sw_product, Discovery Maps from samp_sw_entitlement_definition, publishers from samp_sw_publisher, and lifecycle content. These objects provide the content context behind the entitlement-import resolution process. If a PPN-related import behaves unexpectedly, reviewing Content lookup can help determine whether the PPN, Product, and Discovery Map actually exist in the instance's current Content Service data. 44. Domain-aware Workspace reporting Current Software Asset Workspace Activity Center queries can apply domain filters to entitlement-import records and errors in domain-separated instances. This means import records/errors visible to an administrator can depend on domain context. Domain visibility should therefore be considered when a bulk import exists but the expected import/error record is not visible in the current Workspace context. 45. Microsoft-specific import validation Microsoft entitlement imports have additional supported validations. If License Duration is Contractual, both start and end dates are required. Step-up license type is supported for Microsoft rather than being a generic license type for every publisher. These checks occur in addition to the software-model/PPN resolution described above. 46. Backend investigation sequence Start with the bulk import in samp_bulk_import and confirm the correct spreadsheet/file and overall import state. If a row failed or requires review, locate the corresponding samp_entitlement_import record and review its error reason together with Publisher Part Number, Publisher, Product, Version, Edition, Platform, Language, Software Model, Metric Group, and License Metric. If a PPN was supplied, locate it in samp_sw_product_definition and confirm it represents the expected publisher/product offering. Confirm the related software product in samp_sw_product and, where relevant, the Discovery Map in samp_sw_entitlement_definition. Determine whether an existing cmdb_software_product_model already represents the PPN/content. If several models match the same Discovery Map conditions, validate which one should be selected manually. If PPN is missing/invalid but Publisher and Product are valid, check com.snc.samp.smcreation_on_entitlement_import and determine whether the expected fallback software model was automatically created with source type entitlement_import. Once the import succeeds, inspect the resulting alm_license and verify software_model, Publisher Part Number, Metric Group, License Metric, rights, license type, agreement type, dates, and other required entitlement values. For current Workspace import reporting, samp_m2m_alm_license_import can help trace created entitlements back to processed import records. 47. Important backend tables Bulk entitlement imports are stored in samp_bulk_import. Row-level import errors/review records are stored in samp_entitlement_import. Created software entitlements are stored in alm_license. Current Workspace import-to-entitlement relationships are represented in samp_m2m_alm_license_import. Software Product Definitions/PPNs are stored in samp_sw_product_definition. Software Products are stored in samp_sw_product. Discovery Maps are stored in samp_sw_entitlement_definition. Software models are stored in cmdb_software_product_model. 48. Important fields and values On the import row, the most important software-resolution inputs are Publisher Part Number, Publisher, Product, Version, Edition, Platform, Language, Install condition name, and Software Model where supplied/resolved. On alm_license, important downstream fields include software_model, license_metric, purchased rights, license type, agreement type, Publisher Part Number, and applicable dates/contract information. On cmdb_software_product_model, the important licensing identity is the combination of Product and applicable Version, Edition, Platform, Language, install conditions, and content relationships rather than only its display name. For import-created fallback models, source type entitlement_import identifies the automatic entitlement-import creation path. 49. Relevant system property com.snc.samp.smcreation_on_entitlement_import — Controls automatic creation of software models during entitlement import when the Publisher Part Number is missing or invalid but valid Publisher and Product values are available. Setting the property to false disables this automatic model-creation path. The property does not make an invalid PPN valid; it controls whether SAM can create a model from the other valid entitlement-import information when the PPN path is unavailable. 50. Compact backend flow Excel file → samp_bulk_import → import row validation → PPN lookup in samp_sw_product_definition → Product/Publisher/Discovery Map content through samp_sw_product / samp_sw_entitlement_definition → existing cmdb_software_product_model reused OR required model created → Metric Group / License Metric validation → successful alm_license creation → import relationship/reporting through samp_m2m_alm_license_import; failures/review remain visible through samp_entitlement_import. Fallback path: PPN empty/invalid → Publisher + Product valid → check com.snc.samp.smcreation_on_entitlement_import → create cmdb_software_product_model with source entitlement_import when enabled → create entitlement. 51. Key points to remember A bulk import is represented by samp_bulk_import; the final entitlement is alm_license. Row-level import errors are surfaced through samp_entitlement_import. PPN/Product Definition content is stored in samp_sw_product_definition. Discovery Maps are stored separately in samp_sw_entitlement_definition. Software models are stored in cmdb_software_product_model. A recognized PPN can link to an existing software model or cause the required model to be created. Multiple purchases can reuse the same software model; SAM does not need one model per entitlement. If several matching software models exist, manual selection can be required. Missing/invalid PPN does not automatically block import when Publisher and Product are valid. com.snc.samp.smcreation_on_entitlement_import controls the fallback automatic model-creation path. Models created through that fallback path use source type entitlement_import. A PPN-not-found error can lead to a custom PPN when an applicable Discovery Map exists. If no Discovery Map exists, the software-content relationship must first be established. Publisher/Product/Version/Edition/Platform/Language help define the licensable identity. Install condition name can also participate in software-model matching. Software Model drives Metric Group, which constrains available License Metrics. Incorrect model resolution during import can later cause reconciliation to leave valid purchased rights unused. PPN, Product Definition, Discovery Map, Software Model, and Entitlement are different layers of the licensing data model. Summary SAM entitlement import is a software-model resolution process as much as it is a data-import process. When a recognized Publisher Part Number is supplied, SAM uses Content Service Product Definition information in samp_sw_product_definition to identify the purchased software offering and connect it to an existing or newly created cmdb_software_product_model. Discovery Maps in samp_sw_entitlement_definition provide the normalized software-content relationships behind that licensing identity. If the PPN is missing or invalid but Publisher and Product are valid, SAM can fall back to automatically creating a software model when com.snc.samp.smcreation_on_entitlement_import allows it; the resulting model is identified with source type entitlement_import. If PPN/content resolution is ambiguous, such as multiple models matching the same Discovery Map conditions, SAM requires manual model selection rather than guessing. If an unknown PPN can be associated with an existing Discovery Map, it can be corrected through a custom PPN path. Once the software model is resolved, it drives downstream licensing information such as Metric Group and available License Metrics, and the successful purchased-right record is stored in alm_license. The complete mental model is: Import row → What PPN/product did the customer buy? → Does Content Service know that PPN? → Which Product Definition/Discovery Map describes it? → Does the correct Software Model already exist? → Reuse or create the model → Resolve licensing attributes → Create alm_license → Use that model later during reconciliation.