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 વેલિડેશન

અમે 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)

આ સક્ષમ કરે છે:

• 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 નો ઉપયોગ કરે છે:

• પ્રોડક્ટ પેજ જનરેટ કરવા માટે

• સ્પેસિફિકેશન ડિસ્પ્લે કરવા માટે

• ફીચર્સ