productdb.json: ഉൽപ്പന്ന ഡാറ്റയുടെ ഏക സത്യ സ്രോതസ്സ്

ഈ ലേഖനം productdb എങ്ങനെ എല്ലാ ഉൽപ്പന്ന ഡാറ്റയ്ക്കും ഏക സത്യ സ്രോതസ്സായി പ്രവർത്തിക്കുന്നു എന്ന് വിശദീകരിക്കുന്നു, ഒരു കേന്ദ്രീകൃത ഫയലിൽ ഘടകങ്ങൾ, സവിശേഷതകൾ, യോജ്യതാ നിയമങ്ങൾ, ബിൽ ഓഫ് മെറ്റീരിയൽ എന്നിവ നിർവചിക്കുന്നു.

പ്രശ്നം: ചിതറിക്കിടക്കുന്ന ഉൽപ്പന്ന ഡാറ്റ

ഉൽപ്പന്ന ഡാറ്റ ഒന്നിലധികം സിസ്റ്റങ്ങളിലായി ചിതറിക്കിടക്കാം:

ഇൻവെന്ററി സിസ്റ്റം: ഭാഗങ്ങളുടെ ചെലവും സ്റ്റോക്ക് നിലയും
ERP സിസ്റ്റം: BOM-കളും നിർമ്മാണ ഡാറ്റയും
വെബ്സൈറ്റ്: ഉൽപ്പന്ന വിവരണങ്ങളും സവിശേഷതകളും
അക്കൗണ്ടിംഗ്: വിലനിർണ്ണയവും ചെലവ് കണക്കുകൂട്ടലും

ഡാറ്റ ചിതറിക്കിടക്കുമ്പോൾ, പൊരുത്തക്കേടുകൾ ഉണ്ടാകുന്നു:

വെബ്സൈറ്റിൽ 16GB റാം കാണിക്കുന്നു, പക്ഷേ ERP 8GB എന്ന് പറയുന്നു
വിലനിർണ്ണയത്തിൽ പഴയ ചെലവ് ഡാറ്റ ഉപയോഗിക്കുന്നു
BOM-കൾ യഥാർത്ഥ ഉൽപ്പന്നങ്ങളുമായി സമന്വയിപ്പിക്കപ്പെട്ടിട്ടില്ല
സവിശേഷതകൾ യാഥാർത്ഥ്യവുമായി പൊരുത്തപ്പെടുന്നില്ല

എല്ലാ സിസ്റ്റങ്ങളും റഫർ ചെയ്യുന്ന ഒരു ഏക സത്യ സ്രോതസ്സ് നമുക്ക് ആവശ്യമാണ്.

പരിഹാരം: productdb.json

productdb.json എന്നത് ഓരോ ഘടകവും, അതിന്റെ സവിശേഷതകൾ, യോജ്യതാ നിയമങ്ങൾ, ഘടകാംശങ്ങൾ എന്നിവ നിർവചിക്കുന്ന ഒരു JSON ഫയലാണ്. എല്ലാ സിസ്റ്റങ്ങളും തുടക്കത്തിൽ ഈ ഫയൽ ലോഡ് ചെയ്യുന്നു.

ഈ ഫയൽ Git-ൽ പതിപ്പ് നിയന്ത്രണത്തിലാണ്, എല്ലാ മാറ്റങ്ങളും ട്രാക്ക് ചെയ്യപ്പെടുകയും ഓഡിറ്റ് ചെയ്യാനാവുകയും ചെയ്യുന്നു.

ഫയൽ ഘടന

ഘടക വിഭാഗം അനുസരിച്ച് ഫയൽ ഓർഗനൈസ് ചെയ്തിരിക്കുന്നു:

{
  "Chassis": { ... },
  "Board": { ... },
# ... (implementation details omitted)

ഓരോ വിഭാഗത്തിലും അവയുടെ പ്രോപ്പർട്ടികളുള്ള ഘടകങ്ങൾ അടങ്ങിയിരിക്കുന്നു.

ഘടക നിർവചനം

ഓരോ ഘടകത്തിനും ഒന്നിലധികം പ്രോപ്പർട്ടികൾ ഉണ്ട്:

അടിസ്ഥാന പ്രോപ്പർട്ടികൾ

class: യോജ്യതാ പൊരുത്തത്തിനുള്ള ഘടക ക്ലാസ്

"class": "THIN_MINI_ITX"

internal: ഇൻവെന്ററി, നിർമ്മാണ എന്നിവയ്ക്കുള്ള ആന്തരിക പേര്

"internal": "Chassis, Treo"

external: വെബ്സൈറ്റ്, മാർക്കറ്റിംഗ് എന്നിവയ്ക്കുള്ള ഉപഭോക്താവിനെ അഭിസംബോധന ചെയ്യുന്ന പേര്

"external": "Thinvent® Treo Mini PC"

weight: ഗ്രാമിൽ ഭൗതിക ഭാരം

"weight": 590

യോജ്യതാ നിയമങ്ങൾ (allows)

allows ഫീൽഡ് ഏത് ഘടകങ്ങളെയാണ് ഒരുമിച്ച് ഉപയോഗിക്കാനാകുന്നത് എന്ന് നിർവചിക്കുന്നു:

"allows": {
  "Board": [
    {"class": "THIN_MINI_ITX"}
# ... (implementation details omitted)

ഇതിനർത്ഥം:

Board: THIN_MINI_ITX ക്ലാസ് ഉള്ള ബോർഡുകൾ മാത്രമേ യോജിക്കൂ
Flash: m.2_SATA ക്ലാസ് ഉള്ള ഫ്ലാഷ് സ്റ്റോറേജ് മാത്രമേ യോജിക്കൂ
Accessories: എല്ലാ ആകസ്സേരികളും യോജിക്കുന്നു

യോജ്യത ഇനിപ്പറയുന്ന രീതിയിൽ വ്യക്തമാക്കാം:

ക്ലാസ്-ആധാരിതം (ഡൈനാമിക്):

{"class": "THIN_MINI_ITX"}

പാർട്ട് ID-ആധാരിതം (എക്സ്പ്ലിസിറ്റ്):

["N100", "N150", "i5-1335U"]

ബിൽ ഓഫ് മെറ്റീരിയൽ (constituents)

constituents ഫീൽഡ് ഏത് ഭാഗങ്ങളാണ് ഈ ഘടകത്തെ ഉണ്ടാക്കുന്നത് എന്ന് നിർവചിക്കുന്നു:

"constituents": [
  {
    "Category": "Custom",
# ... (implementation details omitted)

ഇത് സാധ്യമാക്കുന്നു:

ചെലവ് കണക്കുകൂട്ടൽ: എല്ലാ ഘടകാംശങ്ങളുടെയും ചെലവ് കൂട്ടുക
നിർമ്മാണം: അസംബ്ലിക്കുള്ള പിക്ക് ലിസ്റ്റുകൾ ജനറേറ്റ് ചെയ്യുക
ഇൻവെന്ററി: ഘടക ഉപയോഗം ട്രാക്ക് ചെയ്യുക

സവിശേഷത നൽകൽ (provides)

provides ഫീൽഡ് ഈ ഘടകം സംഭാവന ചെയ്യുന്ന സവിശേഷതകൾ നിർവചിക്കുന്നു:

"provides": {
  "Operating Temperature": "0°C ~ 40°C",
  "Operating Humidity": "20% ~ 80% RH, non condensing",
# ... (implementation details omitted)

ഒരു SKU-യിലെ എല്ലാ ഘടകങ്ങളിൽ നിന്നുമുള്ള ഈ സവിശേഷതകൾ ഉൽപ്പന്നത്തിന്റെ പൂർണ്ണമായ സവിശേഷത സൃഷ്ടിക്കാൻ സംഗ്രഹിക്കപ്പെടുന്നു.

ഉദാഹരണം: Treo Chassis

{
  "Treo": {
    "class": "THIN_MINI_ITX",
# ... (implementation details omitted)

ഉദാഹരണം: N100 Board

{
  "N100": {
    "class": "THIN_MINI_ITX",
# ... (implementation details omitted)

productdb.json ലോഡ് ചെയ്യുന്നു

ആപ്ലിക്കേഷൻ തുടക്കത്തിൽ ഫയൽ ലോഡ് ചെയ്യുന്നു:

import json

with open(PRODUCTDB_JSON_PATH, "r", encoding="utf-8") as productdb_file:
    productdb = json.load(productdb_file)

ഇത് ഒരു ഇൻ-മെമ്മറി ഡിക്ഷണറി സൃഷ്ടിക്കുന്നു:

productdb = {
    "Chassis": {
        "Treo": { ... },
# ... (implementation details omitted)

ഉൽപ്പന്ന ഡാറ്റയ്ക്കായി എല്ലാ കോഡും ഈ ഡിക്ഷണറിയെ റഫർ ചെയ്യുന്നു.

ഘടക ഡാറ്റയിലേക്ക് പ്രവേശിക്കുന്നു

വിഭാഗവും ID-യും അനുസരിച്ച് ഘടകം നേടുക

chassis = productdb["Chassis"]["Treo"]
board = productdb["Board"]["N100"]
ram = productdb["RAM"]["8"]

ബാഹ്യ പേര് നേടുക

name = productdb["Board"]["N100"]["external"]
# Result: "Intel® N100 Processor"

സവിശേഷതകൾ നേടുക

features = productdb["Board"]["N100"]["provides"]
# Result: {"Generation": "12th", "Series": "N", ...}

ഘടകാംശങ്ങൾ നേടുക

constituents = productdb["Chassis"]["Treo"]["constituents"]
# Result: [{"Category": "Custom", "PartID": "base_treo", "qty": 1}, ...]

SKU വാലിഡേഷൻ

SKU-കൾ വാലിഡേറ്റ് ചെയ്യാൻ ഞങ്ങൾ productdb.json ഉപയോഗിക്കുന്നു:

def check_sku(sku:str) -> bool:
    parts = sku.split("-")
    mapped_parts = map_parts_to_fields(parts)
# ... (implementation details omitted)

വിശദാംശങ്ങൾക്ക് SKU Structure കാണുക.

സവിശേഷത സംഗ്രഹണം

ഒരു SKU-യിലെ എല്ലാ ഘടകങ്ങളിൽ നിന്നുമുള്ള സവിശേഷതകൾ ഞങ്ങൾ സംഗ്രഹിക്കുന്നു:

def get_product_features(sku: str) -> dict:
    partids = sku.split("-")
    features = {}
# ... (implementation details omitted)

ഉദാഹരണം:

SKU: Treo-N100-8-256-2H-W6-11P

Features:

- Form Factor: Mini PC (from Treo)

- Generation: 12th (from N100)

- Series: N (from N100)

- Cores: 4 (from N100)

- Main Memory: 8 (from 8)

- SSD Storage: 256 (from 256)

- HDMI: 2 (from 2H)

- Operating System: Windows 11 Pro (from 11P)

വിശദാംശങ്ങൾക്ക് Feature Extraction കാണുക.

ചെലവ് കണക്കുകൂട്ടൽ

ഘടകാംശ ചെലവുകൾ കൂട്ടിച്ചേർത്ത് ഞങ്ങൾ SKU ചെലവ് കണക്കാക്കുന്നു:

def calculate_cost(item: dict, partid: str) -> tuple:
    if "constituents" in item:
        # Composite item: sum constituent costs
# ... (implementation details omitted)

ഈ റിക്രേസിവ് കണക്കുകൂട്ടൽ നെസ്റ്റഡ് ഘടകാംശങ്ങൾ കൈകാര്യം ചെയ്യുന്നു.

കോംപോസിറ്റ് ഇനങ്ങൾ

ചില ഘടകങ്ങൾ കോംപോസിറ്റ് ആണ് (മറ്റ് ഘടകങ്ങളാൽ നിർമ്മിച്ചത്):

ഉദാഹരണം: കീബോർഡ് + മൗസ് കോംബോ

{
  "KM": {
    "internal": "Keyboard + Mouse",
# ... (implementation details omitted)