timex_datalink_caldav 0.2.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6c7e200c3fbb1011bd0b0b67b98db758f8802b72d8686ceb991b4766cb285860
-  data.tar.gz: e5b0052df0811f4af6f52c34727bd26bd93254903fdc218e9be00d51ae5ac169
+  metadata.gz: e70c9183de68e607682770a4085c86d87ba3cc0d09105c6867b445a702d8808d
+  data.tar.gz: 6f4248f1fc332ce55c3c7b2850a8b49ccc42d6456301235225032fb2aeb1d80e
 SHA512:
-  metadata.gz: b07bd1855b0b9ffe5a36301c239df18f588bacfd7c1ba6f3e20988057cab7491343dc86072ad43bd5194e0c67e5d25ccb9d4f252214953dd8ed2a793819d9a72
-  data.tar.gz: 529e2275b9207f501414c41131df0e505ae85e46ae8319a4ab0c04a35275b85be393c84b022e0e10890e3072ff4969a351aa55da453a3183b240bc9db19df94f
+  metadata.gz: 925f98b03e5797567d02b7640febc98338c0fc9dacffa0c5771d501c266c9ee4dc59667752b489db851a1f8fe9cc4d4349fab0094ceab3f8f3de4e339731be30
+  data.tar.gz: 7b78a3c9ae837604bff285c6584f1dc84ae32279ce3f99ee0e32d8037f37dd3832451f07aeacca2a5e102d4a2a4016c1b5c6bc570e2aa9d31f04167975a79288

data/Gemfile

@@ -18,3 +18,9 @@ gem "icalendar", "~> 2.8"
 gem "icalendar-recurrence", "~> 1.1"
 
 gem "activesupport", "~> 7.0"
+
+gem "tzinfo", "~> 2.0"
+
+gem "yaml", "~> 0.2.1"
+
+gem "open-uri", "~> 0.3.0"

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    timex_datalink_caldav (0.1.0)
+    timex_datalink_caldav (0.3.0)
 
 GEM
   remote: https://rubygems.org/
@@ -21,6 +21,7 @@ GEM
       nokogiri
     concurrent-ruby (1.2.2)
     crc (0.4.2)
+    date (3.3.3)
     diff-lcs (1.5.0)
     domain_name (0.5.20190701)
       unf (>= 0.0.5, < 1.0.0)
@@ -51,6 +52,10 @@ GEM
     minitest (5.18.0)
     nokogiri (1.14.4-arm64-darwin)
       racc (~> 1.4)
+    open-uri (0.3.0)
+      stringio
+      time
+      uri
     public_suffix (5.0.1)
     racc (1.6.2)
     rake (13.0.6)
@@ -69,6 +74,9 @@ GEM
     rspec-support (3.12.0)
     rubyserial (0.6.0)
       ffi (~> 1.9, >= 1.9.3)
+    stringio (3.0.6)
+    time (0.2.2)
+      date
     timex_datalink_client (0.11.0)
       activemodel (~> 7.0.4)
       crc (~> 0.4.2)
@@ -79,6 +87,8 @@ GEM
     unf (0.1.4)
       unf_ext
     unf_ext (0.0.8.2)
+    uri (0.12.1)
+    yaml (0.2.1)
 
 PLATFORMS
   arm64-darwin-22
@@ -88,10 +98,13 @@ DEPENDENCIES
   calendav (~> 0.4.0)
   icalendar (~> 2.8)
   icalendar-recurrence (~> 1.1)
+  open-uri (~> 0.3.0)
   rake (~> 13.0)
   rspec (~> 3.12)
   timex_datalink_caldav!
   timex_datalink_client (~> 0.11.0)
+  tzinfo (~> 2.0)
+  yaml (~> 0.2.1)
 
 BUNDLED WITH
    2.4.10

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Willy Hardy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -1,6 +1,10 @@
 # TimexDatalinkCaldav
 
-TimexDatalinkCaldav is a simple Ruby gem designed to sync events from a CalDAV server to a Timex Datalink watch. It can also be used as a standalone command-line interface (CLI) tool.
+TimexDatalinkCaldav is a simple Ruby gem designed to sync events from a CalDAV server or an ical formatted ics file to a Timex Datalink watch. It can also be used as a standalone command-line interface (CLI) tool.
+
+## Pre-requisites
+
+If you need to install Ruby, follow the Ruby installation instructions [here](https://www.ruby-lang.org/en/documentation/installation/).
 
 ## Installation
 
@@ -13,9 +17,7 @@ gem install timex_datalink_caldav
 Or add this line to your application's Gemfile:
 
 ```ruby
-source "https://rubygems.pkg.github.com/wjhrdy" do
-  gem "timex_datalink_caldav"
-end
+gem "timex_datalink_caldav"
 ```
 
 And then execute:
@@ -33,26 +35,47 @@ Here's an example of how to use the tool in your Ruby code:
 ```ruby
 require 'timex_datalink_caldav'
 
-client = TimexDatalinkCaldav::Client.new(your_username, your_password, your_server_uri, your_device)
-client.sync_to_watch
+client = TimexDatalinkCaldav::Client.new(your_username, your_password, your_server_uri, your_device, your_protocol_version, days_forward)
+
+client.parse_events
+client.write_to_watch
 ```
 
 ### As a CLI Tool
 
-After installing the gem, you can use it as a CLI tool:
+After installing the gem, you can use it as a CLI tool. You can specify the CalDAV server details directly on the command line:
 
 ```sh
-timex_datalink_caldav -u https://caldavendpoint.com -n your_username -p your_password -d your_device
+timex_datalink_caldav -u https://caldavendpoint.com -n your_username -p your_password -d your_device -a your_protocol_version -f days_forward
 ```
 
-Please replace `your_username`, `your_password`, and `your_device` with your actual CalDAV server username, password, and device respectively. In this example, we're using Apple's iCloud CalDAV server. You'll need to replace this with the URI of your own CalDAV server if you're not using iCloud.
+Please replace `https://caldavendpoint.com`, `your_username`, `your_password`, `your_device`, `your_protocol_version`, and `days_forward` with your actual CalDAV server URI, username, password, serial device, protocol version, and number of days to look forward for events, respectively.
+
+Or you can provide these details in a configuration file:
+
+```sh
+timex_datalink_caldav -c config.yml -a 1 -d /dev/tty.usbmodem0000000000001 -f 7
+```
+
+The configuration file should be a YAML file in the following format:
+
+```yaml
+endpoints:
+  - uri: https://www.google.com/calendar/dav/email@gmail.com/events
+    user: email@gmail.com
+    password: app_password
+  - uri: https://caldavendpoint2.com
+    user: your_username2
+    password: your_password2
+  - uri: https://icalendpoint.com/example.ics
+```
 
-## Note
+The device is a serial device that flashes an led when it receives data. On Linux, this is usually `/dev/tty*`. On macOS, this is usually `$(ls /dev/tty.usbmodem* | head -n 1)`. On Windows, this is usually `COM1`.
 
-Ensure you have the necessary dependencies installed on your system and you have the correct permissions to access the specified device. 
+If you want to use this, I highly recommend pairing it with the Raspberry Pi Pico and [this project](https://github.com/famiclone6502/DIY_Datalink_Adapter). It is the cheapest and easiest way to get a serial device that works with the Timex Datalink watch.
 
-The tool currently works with events that have attendees and converts event times to Eastern Standard Time (EST). Events are sorted by time before syncing to the watch.
+## Notes
 
-## Resources
+- This gem is not affiliated with Timex, nor is it affiliated with any CalDAV server. It is simply a tool that I wrote to sync my events from my CalDAV server to my Timex Datalink watch.
 
-If you want to use this I highly recommend pairing it with the Raspberry Pi Pico and [this project](https://github.com/famiclone6502/DIY_Datalink_Adapter).
+- This gem uses the anniversary feature for full day events, and the appointments feature for events with a start and end time.

data/examples/README.md

@@ -0,0 +1,7 @@
+# Examples
+
+This directory contains sample configurations and code for the timex_datalink_caldav gem.
+
+## Configuration
+
+`caldav.yaml.sample` is a sample configuration file for CalDAV endpoints. You should rename it to `caldav.yaml` and adjust the URI, username, and password for your endpoints.

data/examples/caldav.yaml.sample

@@ -0,0 +1,8 @@
+endpoints:
+  - uri: https://example.com/caldav1
+    user: user1
+    password: password1
+  - uri: https://example.com/caldav2
+    user: user2
+    password: password2
+  - uri: https://example.com/example.ical

data/lib/timex_datalink_caldav/client.rb

@@ -1,15 +1,30 @@
 require 'calendav'
+require 'icalendar'
 require 'icalendar/recurrence'
 require 'timex_datalink_client'
 require 'active_support/time'
+require 'tzinfo'
 
 module TimexDatalinkCaldav
   class Client
-    def initialize(user, password, server_url, serial_device)
+    def initialize(user, password, server_url, serial_device, protocol_version, days_forward = 1)
       @user = user
       @password = password
       @server_url = server_url
       @serial_device = serial_device
+      @days_forward = days_forward
+      @protocol_version = protocol_version.to_i
+      @protocol_class = case @protocol_version
+                        when 1 then TimexDatalinkClient::Protocol1
+                        when 3 then TimexDatalinkClient::Protocol3
+                        when 4 then TimexDatalinkClient::Protocol4
+                        else
+                          raise ArgumentError, "Invalid protocol version: #{@protocol_version}"
+                        end
+                      end
+
+    def get_localzone
+      TZInfo::Timezone.get(TZInfo::Timezone.all_country_zones.detect {|z| z.period_for_local(Time.now).utc_total_offset == Time.now.utc_offset}.identifier)
     end
 
     def get_events
@@ -20,68 +35,130 @@ module TimexDatalinkCaldav
         authentication: :basic_auth
       )
 
-      # Create a new client with the credentials
-      client = Calendav.client(credentials)
+      if @user && @password
+        # Create a new client with the credentials
+        client = Calendav.client(credentials)
+
+        # Get events from the calendar for the next day
+        caldav_events = client.events.list(@server_url, from: Time.now, to: Time.now + @days_forward*24*60*60)
+        events = caldav_events.map { |event| Icalendar::Event.parse(event.calendar_data).first }
+      else
+        cal_file = URI.open(@server_url)
+        cals = Icalendar::Calendar.parse(cal_file)
+        cal = cals.first
+        events = cal.events
+      end
 
-      # Get events from the calendar for the next day
-      client.events.list(@server_url, from: Time.now, to: Time.now + 24*60*60)
+      events
     end
 
-    def sync_to_watch
+    def parse_events
       events = get_events
-
+    
       appointments = []
+      anniversaries = []
       appointment_map = {} # Used to avoid duplicate appointments
-
+      anniversary_map = {} # Used to avoid duplicate anniversaries
+      
       events.each do |event|
-        ical_events = Icalendar::Event.parse(event.calendar_data)
-        if ical_events.any?
-          ical_event = ical_events.first
-          if ical_event.attendee&.any? # Exclude events without attendees
-            next_occurrence = ical_event.occurrences_between(Time.now, Time.now + 24*60*60).first
-            if next_occurrence
-              est_time = next_occurrence.start_time.in_time_zone('Eastern Time (US & Canada)')
-              key = "#{est_time}_#{ical_event.summary.to_s}"
-              unless appointment_map[key] # Check if the event is already in the map
-                puts "Adding appointment: #{ical_event.summary.to_s} at time #{est_time}"
-                appointment = TimexDatalinkClient::Protocol1::Eeprom::Appointment.new(
-                  time: est_time,
-                  message: ical_event.summary.to_s
-                )
-                appointments << appointment
-                appointment_map[key] = true
-              end
+        next unless event
+
+        if event.dtstart && event.dtend && (event.dtend.to_date - event.dtstart.to_date == 1) && event.dtstart.to_datetime.hour == 0 && event.dtstart.to_datetime.min == 0 && event.dtend.to_datetime.hour == 0 && event.dtend.to_datetime.min == 0 # Checking if it is an all day event
+          occurrences = event.occurrences_between(Time.now, Time.now + @days_forward*24*60*60)
+          occurrences.each do |occurrence|
+            est_time = occurrence.start_time.in_time_zone(get_localzone)
+            key = "#{est_time}_#{event.summary.to_s}"
+            puts key
+            unless anniversary_map[key] # Check if the event is already in the map
+              puts "Adding anniversary: #{event.summary.to_s} at date #{event.dtstart.to_s}"
+              anniversary = @protocol_class::Eeprom::Anniversary.new(
+                time: event.dtstart.to_time,
+                anniversary: event.summary.to_s
+              )
+              anniversaries << anniversary
+              anniversary_map[key] = true
+            end
+          end
+        elsif event.dtstart && event.dtend
+          occurrences = event.occurrences_between(Time.now, Time.now + @days_forward*24*60*60)
+          occurrences.each do |occurrence|
+            est_time = occurrence.start_time.in_time_zone(get_localzone)
+            key = "#{est_time}_#{event.summary.to_s}"
+            unless appointment_map[key] # Check if the event is already in the map
+              puts "Adding appointment: #{event.summary.to_s} at time #{est_time}"
+              appointment = @protocol_class::Eeprom::Appointment.new(
+                time: est_time,
+                message: event.summary.to_s
+              )
+              appointments << appointment
+              appointment_map[key] = true
             end
           end
         end
       end
       
-      # Sort the appointments by time
-      appointments.sort_by! { |appointment| appointment.time }
-      write_to_watch(appointments)
+      [appointments, anniversaries]
     end
 
-    def write_to_watch(appointments)
-      time1 = Time.now
-
-      models = [
-        TimexDatalinkClient::Protocol1::Sync.new,
-        TimexDatalinkClient::Protocol1::Start.new,
-        TimexDatalinkClient::Protocol1::Time.new(
+    def write_to_watch(appointments, anniversaries)
+      appointments.sort_by! { |appointment| appointment.time }
+      # add 3 because it always seems to be about 3 seconds behind.
+      time1 = Time.now + 3
+      time2 = time1.dup.utc
+      
+      if @protocol_version == 1
+        time_model = @protocol_class::Time.new(
           zone: 1,
           time: time1,
           is_24h: false
-        ),
-        TimexDatalinkClient::Protocol1::TimeName.new(
+        )
+        time_name_model = @protocol_class::TimeName.new(
           zone: 1,
           name: time1.zone
-        ),
-        TimexDatalinkClient::Protocol1::Eeprom.new(
+        )
+        utc_time_model = @protocol_class::Time.new(
+          zone: 2,
+          time: time2,
+          is_24h: true
+        )
+        utc_time_name_model = @protocol_class::TimeName.new(
+          zone: 2,
+          name: time2.zone
+        )
+      else
+        time_model = @protocol_class::Time.new(
+          zone: 1,
+          name: time1.zone,
+          time: time1,
+          is_24h: false,
+          date_format: "%_m-%d-%y"
+        )
+        utc_time_model = @protocol_class::Time.new(
+          zone: 2,
+          name: "UTC",
+          time: time2,
+          is_24h: true,
+          date_format: "%y-%m-%d"
+        )
+        time_name_model = nil # Not needed for protocol version 3 and 4
+        utc_time_name_model = nil # Not needed for protocol version 3 and 4
+
+      end
+
+      models = [
+        @protocol_class::Sync.new,
+        @protocol_class::Start.new,
+        time_model,
+        time_name_model,
+        utc_time_model,
+        utc_time_name_model,
+        @protocol_class::Eeprom.new(
           appointments: appointments,
+          anniversaries: anniversaries,
           appointment_notification_minutes: 5
         ),
-        TimexDatalinkClient::Protocol1::End.new
-      ]
+        @protocol_class::End.new
+      ].compact # Remove any nil entries
 
       timex_datalink_client = TimexDatalinkClient.new(
         serial_device: @serial_device,

data/lib/timex_datalink_caldav/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module TimexDatalinkCaldav
-  VERSION = "0.2.0"
+  VERSION = "1.0.0"
 end

data/lib/timex_datalink_caldav.rb

@@ -1,6 +1,6 @@
-# frozen_string_literal: true
 require 'optparse'
-
+require 'yaml'
+require 'open-uri'
 require_relative "timex_datalink_caldav/client"
 
 module TimexDatalinkCaldav
@@ -10,34 +10,72 @@ module TimexDatalinkCaldav
     end
 
     def execute
-      client = TimexDatalinkCaldav::Client.new(@options.fetch(:user), @options.fetch(:password), @options.fetch(:uri), @options.fetch(:device))
-      client.sync_to_watch
+      all_appointments = []
+      all_anniversaries = []
+      
+      @options[:endpoints].each do |endpoint|
+        client = TimexDatalinkCaldav::Client.new(endpoint[:user], endpoint[:password], endpoint[:uri], @options[:device], @options[:api], @options[:days_forward])
+        appointments, anniversaries = client.parse_events
+        all_appointments.concat(appointments) if appointments.any?
+        all_anniversaries.concat(anniversaries) if anniversaries.any?
+      end
+    
+      if all_appointments.any? || all_anniversaries.any?
+        client = TimexDatalinkCaldav::Client.new(
+          @options[:endpoints][0][:user],
+          @options[:endpoints][0][:password],
+          @options[:endpoints][0][:uri],
+          @options[:device],
+          @options[:api],
+          @options[:days_forward]
+        )
+        client.write_to_watch(all_appointments, all_anniversaries)
+      end
     end
 
     private
 
     def parse_options(arguments)
-      options = {}
+      options = { days_forward: 1 }
+      cli_endpoint = {}
       OptionParser.new do |opts|
         opts.banner = "Usage: timex_datalink_caldav [options]"
 
+        opts.on("-c", "--config FILE", "Configuration file") do |v|
+          raise ArgumentError, "Both CLI options and configuration file provided. Please provide only one." if cli_endpoint.any?
+          parsed_config = YAML.load_file(v)
+          options[:endpoints] = parsed_config['endpoints'].map do |endpoint|
+            endpoint.each_with_object({}) { |(k, v), result| result[k.to_sym] = v }
+          end
+        end
+
         opts.on("-u", "--uri URI", "CalDAV server URI") do |v|
-          options[:uri] = v
+          cli_endpoint[:uri] = v
         end
 
         opts.on("-n", "--user USERNAME", "Username for CalDAV server") do |v|
-          options[:user] = v
+          cli_endpoint[:user] = v
         end
 
         opts.on("-p", "--password PASSWORD", "Password for CalDAV server") do |v|
-          options[:password] = v
+          cli_endpoint[:password] = v
         end
 
         opts.on("-d", "--device DEVICE", "Serial device for Timex Datalink watch") do |v|
           options[:device] = v
         end
+
+        opts.on("-a", "--api PROTOCOL_VERSION", "Protocol Version") do |v|
+          options[:api] = v
+        end
+
+        opts.on("-f", "--forward DAYS", Integer, "Number of days to look forward for events") do |v|
+          options[:days_forward] = v
+        end
       end.parse!(arguments)
+      
+      options[:endpoints] = [cli_endpoint] if cli_endpoint.any? and options[:endpoints].nil?
       options
     end
   end
-end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: timex_datalink_caldav
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Willy Hardy
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-05-15 00:00:00.000000000 Z
+date: 2023-05-19 00:00:00.000000000 Z
 dependencies: []
 description: 'Adds a CLI and a feature to pull your next day of calendar events into
   the Timex Datalink watch. Note: Hardcoded protocol1 and EST timezone. At the moment.'
@@ -19,13 +19,15 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- ".DS_Store"
 - CHANGELOG.md
 - Gemfile
 - Gemfile.lock
+- LICENSE
 - README.md
 - Rakefile
 - bin/timex_datalink_caldav
+- examples/README.md
+- examples/caldav.yaml.sample
 - lib/timex_datalink_caldav.rb
 - lib/timex_datalink_caldav/client.rb
 - lib/timex_datalink_caldav/version.rb