Home Assistant

Connect CALinONE with Home Assistant and automate your smart home based on your appointments and shifts.

🔗

What does the integration do?

CALinONE comes with its own Home Assistant integration (installable via HACS). It automatically creates a calendar and matching sensors — you don't need to configure anything manually:

Real HA entities: calendar and sensors survive restarts, roll over to the new day at midnight by themselves, and keep working even when the app is closed or your phone is off.
Always up to date: the app sends every change straight to Home Assistant — the integration does the rest.

This lets you build automations like:

Ramp up the heating at 5 AM, but only when you're working
Turn off the lights at 9:30 PM when you have an early shift tomorrow
Get a reminder 30 minutes before your next appointment
Mute phone notifications while you're on vacation

✅

Setup — three steps

1. Install the integration (HACS)

The button opens HACS directly in your Home Assistant and suggests adding the CALinONE repository:

Open CALinONE in HACS

Or manually: in HACS, add the URL https://github.com/Igeling/CALinONE-HomeAssistant under Custom repositories (type “Integration”), install “CALinONE” and restart Home Assistant.

2. Add the integration

There's a shortcut for this too — the button starts the setup dialog directly in your Home Assistant:

Set up the integration in HA

Or manually:

Go to Settings → Devices & Services → Add Integration and search for “CALinONE”
Confirm the dialog — Home Assistant shows you a webhook URL (e.g. https://your-ha:8123/api/webhook/abc123…)
Copy this URL

3. Connect the app

Activate CALinONE Pro in the app (the HA integration is a Pro feature)
Open CALinONE → Settings → Home Assistant and paste the webhook URL
Tap “Test connection” — the app verifies the connection and immediately sends your complete schedule

That's it! No further configuration needed.

🔄

How synchronization works

Direction: App → HA only (one way). Changes in HA are not written back to the app.
Timing: Immediately on every change (briefly batched, ~2 seconds) — including when applying entire rotations.
Full snapshot: The app always sends your complete schedule in a rolling window (3 months back to 12 months ahead, including appointments); the integration fully replaces the previous state. No duplicates, no stale entries.
Independent of the app: The integration stores the schedule in Home Assistant and computes all sensor values itself — across restarts and midnight.
Trigger your own automations: whenever new schedule data arrives you can react to it directly in Home Assistant — the integration provides a matching trigger for it (event calinone_updated).

📡

Which entities are created

The integration provides all entities automatically; display names follow your Home Assistant language, the entity IDs are fixed:

Entity ID	What it shows	Example
`calendar.calinone`	All shifts, vacations and appointments as a calendar	—
`sensor.calinone_current_shift`	Today's shift (or `off`)	`Early shift`
`sensor.calinone_shift_start`	Shift start today (else `-`)	`06:00`
`sensor.calinone_shift_end`	Shift end today (else `-`)	`14:00`
`sensor.calinone_shift_duration`	Shift duration today in hours (night shifts handled correctly)	`8.0`
`sensor.calinone_next_shift`	Shift/vacation tomorrow (or `off`)	`Late shift`
`sensor.calinone_next_appointment`	Next appointment today — automatically advances after an appointment starts (else `off`)	`Dentist`
`sensor.calinone_appointment_category`	Category of that appointment (`-` = no category, `off` = no appointment)	`Doctor`
`binary_sensor.calinone_work_day`	On = work day today (off on vacation days)	`on`
`binary_sensor.calinone_vacation_today`	On = vacation/absence today	`off`

This is what entries look like in the calendar:

Entry type	Display	Example
Shift	Short name – shift name (timed if times are set)	`F – Early shift`
Vacation/absence	Emoji + vacation type (all-day)	`🏖 Vacation`
Appointment	Emoji + time + title (+ location)	`📌 14:00 Meeting`

The sensors are always up to date — you can use them directly in any automation. Four examples:

Example 1: Ramp up heating when you're working

Goal: At 5 AM the heating should go to 22°C — but only on work days.

Settings → Automations → Create Automation
Trigger: Time → 05:00:00
Condition: State → Entity: binary_sensor.calinone_work_day → State: on
Action: climate: set_temperature → Entity: your thermostat → Temperature: 22

Example 2: Turn lights off earlier before an early shift

Goal: If you have to get up early tomorrow, the bedroom light turns off at 9:30 PM.

Trigger: Time → 21:30:00
Condition: State → Entity: sensor.calinone_next_shift → State: Early shift (exactly the shift name from CALinONE)
Action: light: turn_off → light.bedroom

Example 3: No phone notifications on vacation

Trigger: State changed → Entity: binary_sensor.calinone_vacation_today → To: on
Action: Send a notification to your phone

Example 4: Reminder 30 minutes before your next appointment

As a template trigger (YAML mode):

trigger:
  - platform: template
    value_template: >
      {% set t = state_attr('sensor.calinone_next_appointment', 'time') %}
      {{ t not in ['-', none] and
         now().strftime('%H:%M') == (today_at(t) - timedelta(minutes=30)).strftime('%H:%M') }}
action:
  - service: notify.mobile_app_your_phone
    data:
      title: "Appointment in 30 minutes"
      message: "{{ states('sensor.calinone_next_appointment') }} at {{ state_attr('sensor.calinone_next_appointment', 'time') }}"

You can also use the CALinONE calendar directly in automations.

Check whether an entry is currently active

In a condition: State → Entity: calendar.calinone → State: on

Check whether it's a specific shift

In a template condition (YAML mode):

{{ state_attr('calendar.calinone', 'message') == 'F – Early shift' }}

You can also use calendar triggers (Trigger → Calendar → calendar.calinone → “Event starts/ends”, optionally with an offset) — handy for “X minutes before a shift starts”.

Template	Result	Explanation
`{{ states('sensor.calinone_current_shift') }}`	`Early shift` or `off`	You're working this shift today
`{{ states('sensor.calinone_shift_start') }}`	`06:00` or `-`	Shift start today
`{{ states('sensor.calinone_shift_end') }}`	`14:00` or `-`	Shift end today
`{{ states('sensor.calinone_shift_duration') \| float }}`	`8.0`	Shift duration today (hours)
`{{ states('sensor.calinone_next_shift') }}`	`Late shift` or `off`	What's up tomorrow
`{{ states('sensor.calinone_next_appointment') }}`	`Dentist` or `off`	Next appointment today
`{{ state_attr('sensor.calinone_next_appointment', 'time') }}`	`14:00` or `-`	Time of the appointment
`{{ state_attr('sensor.calinone_next_appointment', 'location') }}`	`Main St 5`	Location of the appointment
`{{ states('sensor.calinone_appointment_category') }}`	`Doctor`, `-` or `off`	Category of the appointment
`{{ is_state('binary_sensor.calinone_work_day', 'on') }}`	`true`/`false`	Work day today?
`{{ is_state('binary_sensor.calinone_vacation_today', 'on') }}`	`true`/`false`	On vacation today?
`{{ state_attr('sensor.calinone_current_shift', 'short_name') }}`	`F`	Short name of the shift
`{{ states('calendar.calinone') }}`	`on`/`off`	on = an entry is currently active

Problem	What you can do
“Test connection” fails	Copied the webhook URL completely? Is the CALinONE integration installed and added in HA? Is Home Assistant reachable from your phone (same URL as in the browser)?
“CALinONE” doesn't appear under “Add Integration”	Restart Home Assistant after installing via HACS.
Sensors show `unavailable`	The app has never pushed yet. Tap “Test connection” in the app — this immediately sends the complete schedule.
Values seem outdated	Open the sync status in the app (cloud icon) → “Sync now”.
Lost the webhook URL	Remove and re-add the integration in HA — a new URL is shown (update it in the app).
An automation doesn't react to the shift name	Shift names in conditions must match CALinONE exactly (e.g. “Early shift”, not “Early shift F”).