meetalendar 0.0.1

data/app/models/comfy/admin/meetalendar/auth_credential.rb

@@ -0,0 +1,22 @@
+require 'attr_encrypted'
+
+class Comfy::Admin::Meetalendar::AuthCredential < ApplicationRecord
+  self.table_name = "meetalendar_auth_credentials"
+
+  # TODO(Schau): There might be a better place for this function
+  def self.expand_env(str)
+    str.gsub(/\$([a-zA-Z_][a-zA-Z0-9_]*)|\${\g<1>}|%\g<1>%/) { ENV[$1] }
+  end
+
+  attr_encrypted :access_token, key: Rails.application.secrets.secret_key_base.to_s.bytes[0..31].pack("c" * 32)
+  attr_encrypted :refresh_token, key: Rails.application.secrets.secret_key_base.to_s.bytes[0..31].pack("c" * 32)
+
+  def scope
+    # NOTE(Schau): Scope expected to be a json parsable string that results in an array.
+    parsed_scope = JSON.parse(self.scope_json)
+    parsed_scope = parsed_scope.empty? ? [] : parsed_scope
+  end
+  def scope=(new_scope)
+    self.scope_json = new_scope.to_json.to_s
+  end
+end

data/app/models/comfy/admin/meetalendar/meetup_group.rb

@@ -0,0 +1,3 @@
+class Comfy::Admin::Meetalendar::MeetupGroup < ApplicationRecord
+  self.table_name = "meetalendar_meetup_groups"
+end

data/app/models/comfy/admin/meetalendar/meetups_calendar_syncer.rb

@@ -0,0 +1,178 @@
+require 'rubygems'
+require 'active_resource'
+
+require "date"
+require_relative "../../../google/auth/store/db_token_store"
+require "google/apis/calendar_v3"
+require "googleauth"
+
+require_relative "../../../../controllers/comfy/admin/meetalendar/meetups_controller"
+
+module Comfy::Admin::Meetalendar::MeetupsCalendarSyncer
+  GOOGLE_CALENDAR_AUTH_OOB_URI ||= "urn:ietf:wg:oauth:2.0:oob".freeze
+  GOOGLE_CALENDAR_AUTH_APPLICATION_NAME ||= "Google Calendar API Ruby MeetupSync".freeze
+  GOOGLE_CALENDAR_AUTH_SCOPE ||= Google::Apis::CalendarV3::AUTH_CALENDAR_EVENTS.freeze
+
+  def self.prepare_authorizer
+    client_id = ::MEETALENDAR_CREDENTIALS_GOOGLE_CALENDAR_CLIENT_ID
+    token_store = Google::Auth::Stores::DbTokenStore.new
+    authorizer = Google::Auth::UserAuthorizer.new client_id, GOOGLE_CALENDAR_AUTH_SCOPE, token_store
+  end
+
+  def self.get_authorization_url
+    self.prepare_authorizer.get_authorization_url base_url: GOOGLE_CALENDAR_AUTH_OOB_URI
+  end
+
+  def self.authorize_and_remember(key_code)
+    authorizer = self.prepare_authorizer
+    user_id = "default"
+
+    begin
+      authorizer.get_and_store_credentials_from_code(user_id: user_id, code: key_code, base_url: GOOGLE_CALENDAR_AUTH_OOB_URI)
+    rescue => exception
+      Rails.logger.error "Authorization of google calendar api failed with exception: #{exception.message}"
+      raise ::ActiveResource::UnauthorizedAccess, "Authorization at google calendar failed."
+    end
+  end
+
+  def self.authorize
+    authorizer = self.prepare_authorizer
+    user_id = "default"
+    credentials = authorizer.get_credentials user_id
+
+    if credentials.nil?
+      Rails.logger.error "Authorization failed as no google calendar api credentials are present."
+      raise ::ActiveResource::UnauthorizedAccess, "Please go to: <host>/admin/meetups in the admin interface of the website and renew the authorization of the calendar api."
+    end
+    credentials
+  end
+
+  def self.add_to_key(current_key_data, to_add_data)
+    return_key_data = current_key_data.nil? ? [] : current_key_data.class == [].class ? current_key_data : [].push(current_key_data)
+    return_key_data.push(to_add_data)
+    return_key_data
+  end
+
+  def self.get_path_authorized(path, args = {})
+    return_hash = {}
+    client = HTTPClient.new
+    token_store = Google::Auth::Stores::DbTokenStore.new
+    loaded_token = token_store.load("meetup")
+    if loaded_token.nil?
+      Rails.logger.error "Authorization failed as no currently authorized meetup api token was present."
+      raise ::ActiveResource::UnauthorizedAccess, "To access this path you need to have authenticated the Meetup API successfully."
+      parsed_path = {}.to_s
+    else
+      # try
+      current_tokens = JSON.parse(loaded_token)
+      request_uri = "https://api.meetup.com" + path.to_s
+      request_query_args = args.merge({"access_token" => (current_tokens["access_token"])})
+      result = client.request("GET", request_uri, request_query_args)
+
+      if result.nil? || result.status == Rack::Utils::SYMBOL_TO_STATUS_CODE[:unauthorized]
+        meetup_credentials = ::MEETALENDAR_CREDENTIALS_MEETUP
+        request_uri = "https://secure.meetup.com/oauth2/access"
+        request_query_args = {"client_id": meetup_credentials["client_id"], "client_secret": meetup_credentials["client_secret"], "grant_type": "refresh_token", "refresh_token": "#{current_tokens["refresh_token"]}"}
+        post_return = client.post_content(request_uri, request_query_args)
+
+        if post_return.nil? || post_return.status == 401
+          Rails.logger.error "Authorization with current token failed and token could not be refreshed. Was authorization to meetup api revoked?"
+          raise ::ActiveResource::UnauthorizedAccess, "To access this path you need to have authenticated the Meetup API successfully."
+        else
+          response = JSON.parse(post_return.to_s)
+          token_store.store("meetup", {"auth_id": "meetup", "client_id": meetup_credentials["client_id"], "access_token": response["access_token"], "refresh_token": response["refresh_token"], "scope": "", "expiration_time_millis": response["expires_in"] * 1000}.to_json.to_s)
+
+          # retry with refreshed token
+          current_tokens = JSON.parse(loaded_token)
+          request_uri = "https://api.meetup.com" + path.to_s
+          request_query_args = args.merge({"access_token" => (current_tokens["access_token"])})
+          result = client.request("GET", request_uri, request_query_args)
+  
+          if result.nil? || result.status == 401
+            # really no success
+            Rails.logger.error "Authorization with current token failed, token was refreshed but authorization still fails. Was authorization to meetup api revoked?"
+            raise ::ActiveResource::UnauthorizedAccess, "To access this path you need to have authenticated the Meetup API successfully."
+          else
+            parsed_path = JSON.parse(result&.body.nil? ? {}.to_s : result.body.to_s)
+          end
+        end
+
+      else
+        parsed_path = JSON.parse(result&.body.nil? ? {}.to_s : result.body.to_s)
+      end
+    end
+
+    parsed_path
+  end
+
+  def self.gather_meetups_in_approved_cities(time_now)
+    @meetups = MeetupGroup.all
+    group_ids = @meetups.map{ |meetup| meetup.group_id }
+    group_ids_approved_cities = @meetups.map{|meetup| ["#{meetup.group_id}", meetup.approved_cities.downcase.split(%r{,\s*})]}.to_h
+
+    request_result = Comfy::Admin::Meetalendar::MeetupsCalendarSyncer.get_path_authorized("/find/upcoming_events", {"page": 200})
+
+    upcoming_events = request_result.nil? ? {} : request_result
+    upcoming_events = upcoming_events.nil? || upcoming_events.empty? ? [] : upcoming_events["events"]
+    upcoming_events_of_groups = upcoming_events.select{|event|
+      !event["group"].nil? &&
+      group_ids.include?(event["group"]["id"]) &&
+      !event["venue"].nil? &&
+      group_ids_approved_cities["#{event["group"]["id"]}"].include?(event['venue']['city'].to_s.downcase)}
+
+    grouped_upcoming_events = upcoming_events_of_groups.group_by{|event| event["group"]["id"]}
+    # NOTE(Schau): Very likely i will be able to refactor this to be more clear.
+    limited_upcoming_events = Hash[grouped_upcoming_events.map{|k, v| [k, v.select{|event| Time.at(Rational(event["time"].to_i, 1000)) > time_now}.sort_by{|event| event["time"].to_i}.take(2)]}].select{|k, v| v.any?}
+    listed_upcoming_events = limited_upcoming_events.map{|k, v| v.first}
+  end
+
+  def self.sync_meetups_to_calendar(listed_upcoming_events)
+    calendar_service = Google::Apis::CalendarV3::CalendarService.new
+    calendar_service.client_options.application_name = GOOGLE_CALENDAR_AUTH_APPLICATION_NAME
+    calendar_service.authorization = authorize
+
+    listed_upcoming_events.each{ |event|
+      if event.key?('venue')
+        venue_name_adress = event['venue']['name'] != event['venue']['address_1'] ? "#{event['venue']['name']}, #{event['venue']['address_1']}" : "#{event['venue']['address_1']}"
+        location = "#{venue_name_adress}, #{event['venue']['city']}, #{event['venue']['localized_country_name']}"
+      else
+        if event.key?('link')
+          location = event['link'].to_s
+        else
+          location = ""
+        end
+      end
+
+      description = event['description'].to_s + (defined?(event['link']) ? "\nLink: " + event['link'].to_s : "")
+      start_date_time = DateTime.parse(Time.at(Rational(event['time'].to_i, 1000)).to_s).to_s
+      end_date_time = DateTime.parse(Time.at(Rational(event['time'].to_i + event['duration'].to_i, 1000)).to_s).to_s
+
+      new_event_hash = {
+        id: Digest::MD5.hexdigest(event['id'].to_s),
+        summary: event['name'].to_s,
+        location: location,
+        description: description,
+        start: {
+          date_time: start_date_time,
+          time_zone: Time.zone.name
+        },
+        end: {
+          date_time: end_date_time,
+          time_zone: Time.zone.name
+        },
+      }
+
+      new_event = Google::Apis::CalendarV3::Event.new(new_event_hash)
+      begin
+        calendar_service.update_event('primary', new_event.id, new_event)
+      rescue # TODO(Schau): If possible, figure out the exact exceptions to minimize "braodness of healing"
+        begin
+          calendar_service.insert_event('primary', new_event)
+        rescue => exception
+            Rails.logger.error "An exception occurred while updating or inserting events into the google calendar. Exception: #{exception.message}"
+            raise ::ActiveResource::ClientError, "Could not update or insert event into the google calendar."
+        end
+      end
+    }
+  end
+end

data/app/models/comfy/admin/meetalendar/meetups_controller_logic.rb

@@ -0,0 +1,77 @@
+require 'rubygems'
+require 'active_resource'
+
+require 'multi_json'
+require_relative "../../../google/auth/store/db_token_store"
+
+module Comfy::Admin::Meetalendar::MeetupsControllerLogic
+  class Comfy::Admin::Meetalendar::MeetupsControllerLogic::SearchResult
+    attr_reader :groups_id_name
+    attr_reader :found_upcoming_grouped_events
+    attr_reader :found_last_grouped_events
+    attr_reader :meetup_groups
+
+    def initialize(groups_id_name, found_upcoming_grouped_events, found_last_grouped_events, meetup_groups)
+      @groups_id_name = groups_id_name
+      @found_upcoming_grouped_events = found_upcoming_grouped_events
+      @found_last_grouped_events = found_last_grouped_events
+      @meetup_groups = meetup_groups
+    end
+  end
+
+  def self.authorize_meetup(request, callback_path)
+    meetup_credentials = ::MEETALENDAR_CREDENTIALS_MEETUP
+
+    redirect_url = "https://secure.meetup.com/oauth2/authorize" +
+      "?client_id=#{meetup_credentials["client_id"]}" +
+      "&response_type=code" +
+      "&redirect_uri=#{request.protocol}#{request.host_with_port}#{callback_path.to_s}"
+  end
+
+  def self.callback(code, request, callback_path)
+    meetup_credentials = ::MEETALENDAR_CREDENTIALS_MEETUP
+
+    request_uri = "https://secure.meetup.com/oauth2/access"
+    request_query_hash = {"client_id": meetup_credentials["client_id"], "client_secret": meetup_credentials["client_secret"], "grant_type": "authorization_code", "redirect_uri": "#{request.protocol}#{request.host_with_port}#{callback_path.to_s}", "code": "#{code}"}
+
+    client = HTTPClient.new
+    begin
+      response = JSON.parse(client.post_content(request_uri, request_query_hash))
+    rescue => ex
+      Rails.logger.error "Failed to authorize Meetup API. Exception in callback: #{ex.message}"
+      raise ::ActiveResource::ClientError, "Failed to authorize Meetup API."
+    end
+
+    if !response.nil?
+      token_store = Google::Auth::Stores::DbTokenStore.new
+      token_store.store("meetup", {"auth_id": "meetup", "client_id": meetup_credentials["client_id"], "access_token": response["access_token"], "refresh_token": response["refresh_token"], "scope": "", "expiration_time_millis": response["expires_in"] * 1000}.to_json.to_s)
+    end
+  end
+
+  def self.search_result(parameters, time_now)
+    group_params = JSON.parse(parameters.nil? ? {} : parameters)
+
+    request_result = Comfy::Admin::Meetalendar::MeetupsCalendarSyncer.get_path_authorized("/find/groups", group_params.merge({"fields" => "last_event"}))
+    groups = request_result.nil? ? {} : request_result
+
+    groups_id_name = groups.map{|g| {id: g["id"].to_i, name: g["name"].to_s, link: g["link"].to_s} }
+    group_ids = groups.map{|g| g["id"]}
+    request_result = Comfy::Admin::Meetalendar::MeetupsCalendarSyncer.get_path_authorized("/find/upcoming_events", {"page": 200})
+    upcoming_events = request_result.nil? ? [] : request_result["events"]
+
+    upcoming_events_of_groups = upcoming_events.select{|e| !e["group"].nil? && group_ids.include?(e["group"]["id"])}
+
+    grouped_upcoming_events = upcoming_events_of_groups.group_by{|e| e["group"]["id"]}
+    limited_upcoming_events = Hash[grouped_upcoming_events.map{|k, v| [k, v.select{|e| Time.at(Rational(e["time"], 1000)) > time_now}.sort_by{|e| e["time"]}.take(2)]}].select{|k, v| v.any?}
+
+    found_upcoming_grouped_events = limited_upcoming_events
+
+    last_events = Hash[groups.group_by{|g| g["id"]}.map{|k, v| [k, v.map{|g| g["last_event"]}]}].select{|k, v| v.any?}
+    found_last_grouped_events = last_events
+
+    meetup_groups = groups.map{|g| Comfy::Admin::Meetalendar::MeetupGroup.new({"group_id": g["id"], "name": g["name"], "approved_cities": "", "group_link": g["link"]})}
+
+    search_result = Comfy::Admin::Meetalendar::MeetupsControllerLogic::SearchResult.new(groups_id_name, found_upcoming_grouped_events, found_last_grouped_events, meetup_groups)
+  end
+
+end

data/app/models/google/auth/store/db_token_store.rb

@@ -0,0 +1,37 @@
+require "googleauth/token_store"
+
+module Google
+  module Auth
+    module Stores
+      class DbTokenStore < Google::Auth::TokenStore
+        # (see Google::Auth::Stores::TokenStore#load)
+        def load id
+          credentials = Comfy::Admin::Meetalendar::AuthCredential.find_by(auth_id: id)
+          !credentials.nil? ?
+          {
+            # NOTE(Schau): The encryption algorithm must decipher the encrypted tokens! It does so in this function call: credentials.access_token and credentials.refresh_token
+            auth_id: credentials.auth_id,
+            client_id: credentials.client_id,
+            access_token: credentials.access_token,
+            refresh_token: credentials.refresh_token,
+            scope: credentials.scope,
+            expiration_time_millis: credentials.expiration_time_millis
+          }.to_json.to_s
+          : nil
+        end
+
+        # (see Google::Auth::Stores::TokenStore#store)
+        def store id, token
+          token_hash = JSON.parse(token).symbolize_keys
+          Comfy::Admin::Meetalendar::AuthCredential.find_or_initialize_by(auth_id: id).update(token_hash)
+        end
+
+        # (see Google::Auth::Stores::TokenStore#delete)
+        def delete id
+          credentials = User.find_by(auth_id: id)
+          credentials.destroy
+        end
+      end
+    end
+  end
+end

data/app/views/comfy/admin/meetalendar/meetups/_authorize_calendar.slim

@@ -0,0 +1,6 @@
+. Enter Returned Key Code here:
+= text_field_tag "key_code", nil, class: "custom-control"
+
+= form.form_actions do
+  = form.submit "Save Key", class: "btn btn-primary"
+  = link_to 'Cancel', comfy_admin_meetalendar_meetups_path(@site), class: "btn btn-link"

data/app/views/comfy/admin/meetalendar/meetups/_edit.slim

@@ -0,0 +1,6 @@
+. Currently approved cities:
+= text_field_tag "edited_approved_cities", @meetup.approved_cities.to_s, class: "custom-control"
+
+= form.form_actions do
+  = form.submit "Save Edited", class: "btn btn-primary"
+  = link_to 'Cancel', edit_comfy_admin_meetalendar_meetup_path(@site), class: "btn btn-link"

data/app/views/comfy/admin/meetalendar/meetups/_search_mask.slim

@@ -0,0 +1,19 @@
+ruby:
+  group_params = '{
+    "country": "DE",
+    "state": "Sachsen",
+    "city": "Dresden",
+    "category_id": 34,
+    "page": 200
+  }'
+  
+= form.text_area :parameters, cols: 80, rows: 21, value: group_params
+
+/ TODO(Schau): One could change the text area with the json approach to text fields so it equals the meetup api (and web console test kit) more closely.
+/ = form.text_field :city
+/ = form.text_field :category_id
+/ ...
+
+= form.form_actions do
+  = form.submit "Search for Meetup Groups", class: "btn btn-primary"
+  = link_to 'Cancel', comfy_admin_meetalendar_meetups_path(@site), class: "btn btn-link"

data/app/views/comfy/admin/meetalendar/meetups/_search_result.slim

@@ -0,0 +1,57 @@
+/ TODO(Schau): How to integrate pagination into this form view? (Is this even possible with data that doesn't live in the database?)
+
+ul.list
+  - @groups_id_name&.each do |group|
+    li
+      .row
+        .col-md-12.d-flex.item
+          .item-content.meetup_group
+
+            .item-title
+              .inputs
+                .checkbox_label
+                  .col-md-8 class="custom-control custom-checkbox float-left"
+                    = check_box_tag "[selected_groups_ids][]", "#{group[:id]}", false, id: "group_#{group[:id]}", class: "custom-control-input"
+                    = label_tag "group_#{group[:id]}", group[:name], class: "custom-control-label"
+                    = hidden_field_tag "[groups]#{group[:id]}[name]", group[:name]
+                    = hidden_field_tag "[groups]#{group[:id]}[group_link]", group[:link]
+                  .col-md-4
+                    = link_to "View on Meetup", group[:link], class: 'btn btn-secondary float-right ml-4'
+                .approved_cities
+                  = text_field_tag "[groups]#{group[:id]}[approved_cities]", nil, class: "custom-control"
+                  / NOTE(Schau): Link_to's that look like buttons, have the city names that where found in the venue hash and on click add that city name to the input field followed by a coma
+
+            .item_meta
+              / TODO(Schau): Make all additional info unfoldable
+              .events
+
+                .past_events
+                  h5 Last Event
+                  - if @found_last_grouped_events&.key?(group[:id])
+                    - @found_last_grouped_events[group[:id]].each do |event|
+                        .event
+                          .name = event["name"].to_s
+                          .time
+                            .start = l(Time.at(Rational(event["time"].to_i, 1000), Rational(event["utc_offset"].to_i, 24*60*601000)), format: :long)
+                          .yes_rsvp_count = event["yes_rsvp_count"].to_s + " Teilnemher"
+
+                span class="border-top my-3"
+
+                .upcoming_events
+                  h5 Upcoming
+                  - if @found_upcoming_grouped_events&.key?(group[:id])
+                    - @found_upcoming_grouped_events[group[:id]].each do |event|
+                      .event
+                        .name = link_to event["name"], event["link"]
+                        .time
+                          .city = "In ".to_s + event.dig("venue", "city").to_s + ", Von ".to_s
+                          .start = l(Time.at(event["time"].to_i.div(1000)), format: :long)
+                          .to bis
+                          .end = l(Time.at((event["time"].to_i + event["duration"].to_i).div(1000)), format: :short)
+                        / TODO(Schau): One could make the city name of the found events clickable so that the user easily can add this city's name to the list of approved cities. (One should research if Meetup has a way to represent each city on the planet with an id that the system gave this city's name. (Or Meetup realy relies on strings, then this doesn't quite make the effort worth.))
+                        .description
+                          = sanitize(event["description"])
+
+= form.form_actions do
+  = form.submit "Add selected Meetup Groups", class: "btn btn-primary"
+  = link_to 'Cancel', comfy_admin_meetalendar_meetups_path(@site), class: "btn btn-link"

data/app/views/comfy/admin/meetalendar/meetups/authorize_calendar.slim

@@ -0,0 +1,6 @@
+.page-header
+  h2= 'Authorize Calendar Access'
+
+.goto_url = link_to "Please follow this link and grant this application access to your calendar.", @goto_url, target: "_blank"
+= comfy_form_with url: :authorize_calendar_comfy_admin_meetalendar_meetups, method: :get do |authorize_calendar|
+  = render 'authorize_calendar', form: authorize_calendar

data/app/views/comfy/admin/meetalendar/meetups/edit.slim

@@ -0,0 +1,11 @@
+.page-header
+  h2 Edit Meetup
+
+.row
+  .col-md-8.item
+    .item-content
+      .item-title
+        = link_to @meetup.name, @meetup.group_link, target: "_blank"
+      .item_meta
+        = comfy_form_with url: :comfy_admin_meetalendar_meetup, method: :patch do |edit|
+          = render 'edit', form: edit

data/app/views/comfy/admin/meetalendar/meetups/index.slim

@@ -0,0 +1,26 @@
+.page-header
+  = link_to 'Add Groups', search_mask_comfy_admin_meetalendar_meetups_path(@site), class: 'btn btn-primary float-right ml-1'
+  = link_to 'Authorize Calendar', authorize_calendar_comfy_admin_meetalendar_meetups_path(@site), class: 'btn btn-secondary float-right ml-1'
+  = link_to 'Authorize Meetup', authorize_meetup_comfy_admin_meetalendar_meetups_path(@site), class: 'btn btn-secondary float-right'
+  h2= 'Subscribed Meetup Groups'
+
+
+= paginate @meetups, theme: 'comfy'
+
+ul.list
+  - @meetups&.each do |meetup_group|
+    li
+      .row
+        .col-md-8.item
+          .item-content
+            .item-title
+              = link_to meetup_group.name, meetup_group.group_link, target: "_blank"
+            .item_meta
+              = "Approved Cities: " + meetup_group.approved_cities.to_s
+
+        .col-md-4.d-flex.align-items-center.justify-content-md-end
+          .btn-group.btn-group-sm
+            = link_to 'Edit', edit_comfy_admin_meetalendar_meetup_path(@site, meetup_group), class: 'btn btn-outline-secondary'
+            = link_to 'Delete', comfy_admin_meetalendar_meetup_path(@site, meetup_group), method: :delete, data: {confirm: 'Are you sure?'}, class: 'btn btn-danger'
+
+= paginate @meetups, theme: 'comfy'