Skip to main content
100%

Gist 61c53a3a4b73821c2fdf

✓ Published0🌍 Public
Aandybak
Last edited Sep 17, 2014
Created on Sep 17, 2014

This example visualizes the relationships between Django model fields, notifier types, and their associated timing rules for invoice reminders. It shows how `Invoice` objects map to different notifier actions (sending invoices, sending reminders 7 days or 1 day before due) through a structured configuration. The code defines an `Invoice` model with `Choices` for notifier types and a `NOTIFIER_EVENTS` dictionary that pairs each reminder type with date-field criteria, time-delta ranges, and status filters. The visualization likely renders this Django model logic as an interactive graph, using Python’s model definitions and timedelta calculations to display the branching decision paths.

AI-generated description

Similar vizzes

Loading thumbnail…

Gist f27e286a30902848d6c4

This example visualizes the relationships between Django model instances and their associated notification rules. It shows how filter conditions map to database query sets, using a static code-based data structure. The visualization relies on Django’s ORM for defining model fields and query filters, while the rendering approach appears to use a custom layout for displaying the rule hierarchy. The code defines a `Something` model with `name` and `type` fields, then constructs a `NOTIFY_RULE` dictionary that filters bookings by a pre-filtered `Location` queryset flagged as `our_base`. No interactive or animated elements are present.

Aandybak
76% match
Loading thumbnail…

Gist 67bed86151bd1a473e5d

This code defines a method that builds a context dictionary for notifier templates. It selects a billing contact based on the booking or account, falling back to a blank Contact instance. The returned dictionary includes invoice details like due date, type, number, total price, and an item table, using the model’s existing fields and methods. The example demonstrates a typical Django model helper for preparing template data.

Aandybak
68% match
Loading thumbnail…

Gist 11191339

This example shows a Django model definition for an inventory event system, mapping various event types—bookings, purchases, cross-hires, repairs, and missing items—to related database records via foreign keys. The code uses Django’s `models.ForeignKey` to link each event to its corresponding office, inventory, or booking entity, with nullable and blankable fields allowing flexible associations. It is a data-model snippet, not a visualization, and does not employ any charting or rendering libraries.

Aandybak
67% match
Loading thumbnail…

Gist 2ad07f5c9a84e6823e08

This example visualizes the class inheritance structure of a Django model, showing how `HasEvents` connects to `HasAdminUrl`, `TimeStampedModel`, and its custom manager requirement. The code uses Python class definitions and a runtime check with `issubclass` to enforce that subclasses inherit from `HasEventsManager`. The visualization renders the relationships between these classes, highlighting the inheritance chain and the manager constraint through a graph layout. The rendering approach relies on the class metadata visible in the source, with the `HasEvents` class at the center of the diagram.

Aandybak
66% match
Loading thumbnail…

Gist 9295126fbe6657c96185

This visualization shows the relationship between Django model fields and their cached property aliases in a database schema. It uses the Django ORM’s `models.DateTimeField` and `models.ForeignKey` to define the base order row’s timestamp and two related inventory item references, while `@cached_property` methods expose either the confirmed stock item or the unconfirmed item model. The code demonstrates how `is_confirmed` switches between the two foreign keys, returning `None` for the unused one. The example relies on Django’s model inheritance and the `cached_property` decorator to manage lazy-loaded relationships, illustrating a pattern where alternate field names are hidden behind a single logical accessor.

Aandybak
62% match
Loading thumbnail…

Gist 9839271

This visualization shows the daily flow of bookings through a Django-based booking system, tracking arrivals and departures on the current day. The code defines a `BookingManager` that filters booking records by timestamps falling within the day’s start and end boundaries, producing two properties: `departures_today` for bookings starting today and `arrivals_today` for bookings ending today. The example demonstrates how to query and aggregate temporal data using Django’s ORM, with the `Booking` model and `models.Manager` class providing the data structure. The visualization itself is not shown in the snippet; only the data-management logic is presented, implying a chart built separately from these queried results.

Aandybak
61% match
Loading thumbnail…

Gist 9839784

This visualization displays Django model query results for hotel bookings, distinguishing arrivals and departures for today and tomorrow through grouped bar charts. The code defines a custom `BookingManager` that filters `Booking.objects` using date-based lookups, combining departure and arrival querysets with union operations (`|`). The rendering likely uses d3.js for bar chart layout, while the data pipeline relies on Python’s `datetime` and `timedelta` calculations to segment time periods. The manager properties expose aggregated counts for each category, feeding directly into the visual representation.

Aandybak
61% match
Loading thumbnail…

Gist 7d3d2123ca922c2ab231

This example demonstrates a code snippet that creates a stock order in a Django-based inventory system. It shows the sequence of operations: instantiating a `PurchaseOrder` with a given supplier, adding a row with the specified quantity, and attaching a hidden arrival event for the creation date and location. The code relies on Django’s object-relational model (`PurchaseOrder.objects.create` and related row creation) to persist the order. It also uses a custom method (`add_hidden_arrival`) to link the order to a location, illustrating how business logic can be embedded in model methods rather than external visualization tools. The rendering approach is not visual; it is a server-side data-handling example.

Aandybak
60% match