logCiCa 2.0 schema

schema.d2

# Logistics Management System LMS
#
# use classes, the same as interface ... ?

# contact, a party could reference multilple contacts (or one ?)

classes: {
  transactionnal: {
    style: {
      stroke-width: 0
      fill: "#44C7B1"
      shadow: true
      border-radius: 5
    }
  }
  governance: {
    style: {
      stroke-width: 0
      fill: "#339FFF"
      shadow: true
      border-radius: 5
    }
  }
  activity: {
    style: {
      stroke-width: 0
      fill: "#FFD433"
      shadow: true
      border-radius: 5
    }
  }
  asset: {
    style: {
      stroke-width: 0
      fill: "#FFAC33"
      shadow: true
      border-radius: 5
    }
  }
}

# tour schema -> every Friday I go around there

organisation: {
  class: governance
}

organisation -> place
organisation -> partnership

partnership: {
  class: governance
  members: {
    shape: person
  }
  roles
}

activity: {
  class: activity
  owner: {
    shape: person
  }
}

workspace: {
  class: asset
  owner: {
    shape: person
  }
}

counter: {
  class: asset
  owner: {
    shape: person
  }
  marketplace
  schedule
}

counter -> workspace
counter.marketplace -> counter
counter -> catalog

party: {
  class: governance
  shape: person
}

party -> organisation
party -> activity
party -> workspace
party -> partnership

order: {
  class: transactionnal
  buyer: {
    shape: person
  }
  seller: {
    shape: person
  }
  lines: {
    shape: page
  }
}

order -> counter
order -> subscription
order -> session
order.lines -> product
order.lines -> catalog item
order.lines -> offer
order.shippingMethod -> method
order.shippingPlace -> place
order.shippingWorkspace -> workspace
order.billingMethod -> method
order.billingPlace -> place
order.billingWorkspace -> workspace
order -> shipment

# best way to link inventory, order and shipment ?
# improve fulfillment, how to link with stock, ...
fulfillment: {
  class: transactionnal
  operator: {
    shape: person
  }
  lines: {
    shape: page
  }
}

fulfillment -> workspace
fulfillment -> order
fulfillment -> shipment
fulfillment -> session
fulfillment.lines -> inventory item

shipment: {
  class: transactionnal
  shipper: {
    shape: person
  }
  carrier: {
    shape: person
  }
  receiver: {
    shape: person
  }
  items: {
    shape: page
  }
}

shipment.pickupPlace -> place
shipment.deliveryPlace -> place
shipment.pickupWorkspace -> workspace
shipment.deliveryWorkspace -> workspace
shipment -> order

shipment.items -> pack item

invoice: {
  class: transactionnal
  buyer: {
    shape: person
  }
  seller: {
    shape: person
  }
  lines: {
    shape: page
  }
}

invoice.lines -> product

# how to play with owner and manager ?
# how to handle offers ?
# how to link catalog ...
# assets such as freezers, ...
# better stuff around stock handling

product: {
  producer: {
    shape: person
  }
  ingredients
}

product -> product group

pack item

pack item -> product
pack item -> pack
pack item -> batch

pack: {
  container
  items: {
    shape: page
  }
}

# pack and container are traçable

pack.items -> pack item

catalog: {
  distributor: {
    shape: person
  }
}

catalog item -> inventory item
catalog item -> product
catalog item -> offer

offer: {
  seller: {
    shape: person
  }
  price
}

offer -> product
offer -> service


inventory item

inventory item -> product
inventory item -> workspace
# inventory item -> batch ??

supplier: {
  owner: {
    shape: person
  }
  subject: {
    shape: person
  }
}

customer: {
  owner: {
    shape: person
  }
  subject: {
    shape: person
  }
}

tour: {
  class: activity
  manager: {
    shape: person
  }
  operator: {
    shape: person
  }
  legs
  stop
}

tour -> activity

tour -> shipment
tour -> task
tour -> vehicle

tour.stop -> workspace
tour.stop -> place

vehicle: {
  class: asset
  owner: {
    # vehicle manager ?
    shape: person
  }
  features
  costs
  compartments: {
    features
    costs
  }
}

place: {
  owner: {
    shape: person
  }
}

method # shipping, fulfillment, ...

# team ? -> part of party ?

batch: {
  class: activity
}

batch -> product

subscription: {
  schedule
}

session: {
  class: activity
  manager: {
    shape: person
  }
}

session -> catalog
session -> activity
session -> counter

flow: {
  class: activity
  items: {
    shape: page
  }
}

flow.items -> pack item

# task.schedule
task: {
  class: activity
  operator: {
    shape: person
  }
}

task -> activity
task.subtasks -> task

service: {
  class: activity
  operator: {
    shape: person
  }
}

category -> classification

code -> code list

profile -> organisation
profile -> session
profile -> activity
profile -> counter
profile -> workspace
profile -> partnership
profile -> place

knowledge base -> place
knowledge element -> knowledge base
knowledge element -> place

recipe: {
  ingredients
}

recipe.ingredients -> product

# scenario
# consolidation