productdb.json: ਉਤਪਾਦ ਡਾਟਾ ਲਈ ਇੱਕੋ ਸਰੋਤ ਸੱਚਾਈ

ਇਹ ਲੇਖ ਦੱਸਦਾ ਹੈ ਕਿ ਕਿਵੇਂ productdb ਸਾਰੇ ਉਤਪਾਦ ਡਾਟਾ ਲਈ ਇੱਕੋ ਸਰੋਤ ਸੱਚਾਈ ਦੇ ਤੌਰ 'ਤੇ ਕੰਮ ਕਰਦਾ ਹੈ, ਜੋ ਕਿ ਇੱਕ ਕੇਂਦਰੀ ਫਾਈਲ ਵਿੱਚ ਕੰਪੋਨੈਂਟਾਂ, ਫੀਚਰਾਂ, ਅਨੁਕੂਲਤਾ ਨਿਯਮਾਂ, ਅਤੇ ਬਿਲ ਆਫ ਮੈਟੀਰੀਅਲ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ।

ਸਮੱਸਿਆ: ਬਿਖਰੇ ਹੋਏ ਉਤਪਾਦ ਡਾਟਾ

ਉਤਪਾਦ ਡਾਟਾ ਕਈ ਸਿਸਟਮਾਂ ਵਿੱਚ ਬਿਖਰਿਆ ਹੋ ਸਕਦਾ ਹੈ:

• ਇਨਵੈਂਟਰੀ ਸਿਸਟਮ: ਪਾਰਟ ਖਰਚੇ ਅਤੇ ਸਟਾਕ ਪੱਧਰ

• ERP ਸਿਸਟਮ: BOMs ਅਤੇ ਨਿਰਮਾਣ ਡਾਟਾ

• ਵੈੱਬਸਾਈਟ: ਉਤਪਾਦ ਵੇਰਵੇ ਅਤੇ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ

• ਲੇਖਾ-ਜੋਖਾ: ਕੀਮਤਾਂ ਅਤੇ ਖਰਚ ਨਿਯਮ

ਜਦੋਂ ਡਾਟਾ ਬਿਖਰਿਆ ਹੁੰਦਾ ਹੈ, ਤਾਂ ਅਸੰਗਤੀਆਂ ਪੈਦਾ ਹੁੰਦੀਆਂ ਹਨ:

• ਵੈੱਬਸਾਈਟ 16GB RAM ਦਿਖਾਉਂਦੀ ਹੈ, ਪਰ ERP 8GB ਦੱਸਦਾ ਹੈ

• ਕੀਮਤਾਂ ਪੁਰਾਣੇ ਖਰਚ ਡਾਟਾ ਦੀ ਵਰਤੋਂ ਕਰਦੀਆਂ ਹਨ

• BOMs ਅਸਲ ਉਤਪਾਦਾਂ ਨਾਲ ਸਿੰਕ ਤੋਂ ਬਾਹਰ ਹਨ

• ਫੀਚਰ ਹਕੀਕਤ ਨਾਲ ਮੇਲ ਨਹੀਂ ਖਾਂਦੇ

ਸਾਨੂੰ ਇੱਕ ਇੱਕੋ ਸਰੋਤ ਸੱਚਾਈ ਦੀ ਲੋੜ ਹੈ ਜਿਸਦਾ ਸਾਰੇ ਸਿਸਟਮ ਹਵਾਲਾ ਦੇਣ।

ਹੱਲ: 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 ਵੈਲਿਡੇਸ਼ਨ

ਅਸੀਂ SKUs ਨੂੰ ਵੈਲਿਡੇਟ ਕਰਨ ਲਈ productdb.json ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ:

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

ਵੇਰਵਿਆਂ ਲਈ SKU ਬਣਤਰ ਵੇਖੋ।

ਫੀਚਰ ਐਗਰੀਗੇਸ਼ਨ

ਅਸੀਂ ਇੱਕ 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)

ਵੇਰਵਿਆਂ ਲਈ ਫੀਚਰ ਐਕਸਟਰੈਕਸ਼ਨ ਵੇਖੋ।

ਖਰਚ ਗਣਨਾ

ਅਸੀਂ ਅੰਗਾਂ ਦੇ ਖਰਚ ਜੋੜ ਕੇ 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)

ਇਹ ਸਮਰੱਥ ਬਣਾਉਂਦਾ ਹੈ:

• BOM ਜਨਰੇਸ਼ਨ: ਜਰੂਰੀ ਸਾਰੇ ਕੰਪੋਨੈਂਟਾਂ ਦੀ ਸੂਚੀ ਬਣਾਓ

• ਖਰਚ ਗਣਨਾ: ਕੀਬੋਰਡ + ਮਾਊਸ + ਡੋਂਗਲ ਦੇ ਖਰਚ ਜੋੜੋ

• ਇਨਵੈਂਟਰੀ ਟਰੈਕਿੰਗ: ਕੰਪੋਨੈਂਟ ਵਰਤੋਂ ਟਰੈਕ ਕਰੋ

productdb.json ਅੱਪਡੇਟ ਕਰਨਾ

ਮੈਨੂਅਲ ਸੰਪਾਦਨ

ਫਾਈਲ ਨੂੰ ਇੱਕ ਟੈਕਸਟ ਐਡੀਟਰ ਜਾਂ IDE ਵਿੱਚ ਮੈਨੂਅਲੀ ਸੰਪਾਦਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਬਦਲਾਅ Git ਵਿੱਚ ਕਮਿਟ ਕੀਤੇ ਜਾਂਦੇ ਹਨ:

git add PATH_TO_FILE/productdb.json
git commit -m "Add new N150 board configuration"
git push

ਵੈਲਿਡੇਸ਼ਨ

ਸੰਪਾਦਨ ਤੋਂ ਬਾਅਦ, JSON ਸਿੰਟੈਕਸ ਨੂੰ ਵੈਲਿਡੇਟ ਕਰੋ:

python -m json.tool PATH_TO_FILE/productdb.json > /dev/null

ਇਹ ਸਿੰਟੈਕਸ ਗਲਤੀਆਂ ਦੀ ਜਾਂਚ ਕਰਦਾ ਹੈ।

ਤੈਨਾਤੀ

Git ਵਿੱਚ ਪੁਸ਼ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਫਾਈਲ ਨੂੰ ਪ੍ਰੋਡਕਸ਼ਨ ਵਿੱਚ ਤੈਨਾਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ

ਐਪਲੀਕੇਸ਼ਨ ਰੀਸਟਾਰਟ 'ਤੇ ਫਾਈਲ ਨੂੰ ਦੁਬਾਰਾ ਲੋਡ ਕਰਦੀ ਹੈ।

ਹੋਰ ਸਿਸਟਮਾਂ ਨਾਲ ਏਕੀਕਰਨ

ਵੈੱਬਸਾਈਟ

ਵੈੱਬਸਾਈਟ productdb.json ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ:

• ਉਤਪਾਦ ਪੇਜ ਤਿਆਰ ਕਰਨ ਲਈ

• ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦਿਖਾਉਣ ਲਈ

• ਫੀਚਰਾਂ ਦੁਆਰਾ ਉਤਪਾਦਾਂ ਨੂੰ ਫਿਲਟਰ