openopus-core-people 1.1.0 → 1.1.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fb6c5d918b4cf8dc73c3c5a22503673dc1ddf9558a8447ef1a505154007753d9
-  data.tar.gz: e749bc852fe3e432d4aae6e3ce33c04135a94fca16cda43c2ccaecc25b3e0942
+  metadata.gz: 6ab650c65f3c0c4bbf10f15ed0a6c0ce275beb9133e6d3ec56577ed043760508
+  data.tar.gz: 94d9e71f0cdb9e4e26a66f0426e8d9b73839c7ce2c1b9e0aee97883331e6fc50
 SHA512:
-  metadata.gz: 5abc7901b229c1850154f628bb6c6efe47bfe3e39ebbf45c0e7d49c4a9286f48c5a1b48af70aaff01fe40ce85d1a148b9f166e83c90fbf371f0eb816aa5f252c
-  data.tar.gz: 9c08ec78f0de97a8e880295e6e01a7db12471371c59c6db043533986d041bef2317fdbee48c7ba6c78a6c1317a6fca432a5641ee75e04d828efdc959ff8c43f9
+  metadata.gz: 8269bb3d92b704b885ca77b85909c0111ea6a64472aefa646da6c2d114efd033bb0282c150972ac49de813ef101f2ba9ab8b2f679cda9c3d6fd77c4402d11144
+  data.tar.gz: c2cdf46236104f440f932b417ff45f6ff300b629d162dd7d35deada4867ac14a8c224aa53c42b5f2357b60732c46a53c16797e6864232991342b35f006368dd1

data/README.md

@@ -17,13 +17,14 @@ Install the gem, run migrations.  This will create human structures, from Organi
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'openopus-core-people', git: "https://github.com/opuslogica/openopus-core-people"
+gem 'openopus-core-people', git: "https://github.com/openopus/openopus-core-people"
 ```
 
 And then execute:
 ```bash
 $ bundle install
-$ bundle exec rake db:migrate
+$ ./bin/rake openopus_core_people_engine:install:migrations
+$ ./bin/rake db:migrate
 ```
 
 Or install it yourself as:

data/Rakefile

@@ -15,12 +15,11 @@ RDoc::Task.new(:rdoc) do |rdoc|
 end
 
 APP_RAKEFILE = File.expand_path("test/dummy/Rakefile", __dir__)
-load 'rails/tasks/engine.rake'
-
+# load 'rails/tasks/engine.rake'
 load 'rails/tasks/statistics.rake'
+load 'lib/tasks/openopus/core/people/tasks.rake'
 
 require 'bundler/gem_tasks'
-
 require 'rake/testtask'
 
 Rake::TestTask.new(:test) do |t|

data/app/models/address.rb

@@ -1,6 +1,6 @@
 class Address < ApplicationRecord
-  belongs_to :label, optional: true
-  belongs_to :addressable, polymorphic: true
+  include Labelize
+  belongs_to :addressable, polymorphic: true, optional: true
 
   accepts_nested_attributes_for :label
   

data/app/models/concerns/labelize.rb

@@ -0,0 +1,26 @@
+# labelize.rb: -*- Ruby -*-  DESCRIPTIVE TEXT.
+# 
+#  Copyright (c) 2019 Brian J. Fox Opus Logica, Inc.
+#  Author: Brian J. Fox (bfox@opuslogica.com)
+#  Birthdate: Wed Sep 11 09:37:52 2019.
+module Labelize
+  extend ActiveSupport::Concern
+  included do
+    belongs_to :label,  optional: true
+
+    def label
+      db_label = super
+      if not db_label
+        self.label = "Work"
+        db_label = super
+      end
+
+      db_label.value
+    end
+
+    def label=(name)
+      super(Label.get(name))
+      self.label
+    end
+  end
+end

data/app/models/email.rb

@@ -1,17 +1,27 @@
 class Email < ApplicationRecord
-  belongs_to :label, optional: true
-  belongs_to :emailable, polymorphic: true
+  include Labelize
+  belongs_to :emailable, polymorphic: true, optional: true
   accepts_nested_attributes_for :label
   before_create :default_label
+  before_save :canonicalize
+
+  VALID_EMAIL_FORMAT_REGEX = /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\Z/i
+
+  validates_format_of :address, with: VALID_EMAIL_FORMAT_REGEX, :on => :create
 
   def self.canonicalize(addr)
-    addr.strip.downcase if not addr.blank?
+    candidate = addr.strip.downcase if not addr.blank?
+    candidate ||= addr
   end
 
   def canonicalize
     self.address = self.class.canonicalize(self.address)
   end
 
+  def self.valid_format?(addr)
+    return (addr =~ VALID_EMAIL_FORMAT_REGEX) != nil
+  end
+  
   def default_label
     self.label = Label.get("Work")
   end

data/app/models/person.rb

@@ -11,12 +11,25 @@ class Person < ApplicationRecord
   accepts_nested_attributes_for :emails
 
   def self.lookup(name)
+    return nil if not name
     person   = self.find_by(self.name_components(name))
     person ||= self.includes(:nicknames).joins(:nicknames).find_by("nicknames.nickname" => name)
+
+    # Maybe we're looking up by phone number?
     if not person
-      people = self.all.collect do |p|
-        [p.id, [(p.fname[0] || ""), (p.minitial[0] || ""), (p.lname[0] || "")].join("").upcase]
-      end
+      phone = Phone.where(number: Phone.canonicalize(name)).first rescue nil
+      person = phone.phoneable if phone
+    end
+
+    if not person
+      email = Email.where(emailable_type: self.name.to_s, address: Email.canonicalize(name.downcase)).first
+      person = email.emailable if email
+    end
+
+    if not person
+      # Try hard to find a person by their initials, even if there wasn't a nickname for them.
+      people = self.all.collect {|p| [p.id, p.initials]}
+
       people.each do |parry|
         if parry[1] == name.upcase
           person = self.find(parry[0])
@@ -25,11 +38,6 @@ class Person < ApplicationRecord
       end
     end
 
-    if not person
-      addr = Email.where(emailable_type: self.name.to_s, address: Email.canonicalize(name.downcase)).first
-      person = addr.person.first if addr
-    end
-
     person
   end
 
@@ -82,7 +90,7 @@ class Person < ApplicationRecord
     result = possibles.include?(text.gsub(/[.]*/, "").downcase) if text.present?
   end
 
-  def self.name_components(name)
+  def self.name_components(name, transformer=nil)
     res = {}
     component = ""
     components = name.gsub(/,/, " ").gsub(/  /, " ").split(" ") rescue [name]
@@ -92,37 +100,56 @@ class Person < ApplicationRecord
     # What kind of thing is this?
     if is_name_prefix?(component)
       res[:prefix] = component
+      res[:prefix] = res[:prefix].send(transformer) if res[:prefix] && transformer
       res[:fname] = components.shift
     else
       res[:fname] = component
     end
 
+    res[:fname] = res[:fname].send(transformer) if res[:fname] && transformer
+
     # Next up, middle initial or last name.
     # If only one word remains, that's the last name
     if components.length == 1
       res[:lname] = components.shift
+      res[:lname] = res[:lname].send(transformer) if res[:lname] && transformer
     elsif components.length > 0
       # At least 2 words remain. We might have middle names, prefixes, suffixes, etc.
       components.reverse!
       component = components.shift
+
       if is_name_suffix?(component)
         res[:suffix] = component
+        res[:suffix] = res[:suffix].send(transformer) if res[:suffix] && transformer
         res[:lname] = components.shift
       else
         res[:lname] = component
       end
+
+      res[:lname] = res[:lname].send(transformer) if res[:lname] && transformer
+
       res[:minitial] = components.shift
+      res[:minitial] = res[:minitial].send(transformer) if res[:minitial] && transformer
+
     end
 
     res[:minitial] = res[:minitial].gsub(/[.]/, "") if res[:minitial].present?
     res
   end
-
+  
+  def initials
+    res = ""
+    res += fname[0] if fname
+    res += minitial[0] if minitial
+    res += lname[0] if lname
+    res.upcase
+  end
+  
   def name
     components = []
 
     if prefix.present?
-      if not prefix.include?(".")
+      if not prefix.include?(".") and not prefix =~ /^miss$/i
         components << "#{prefix}."
       else
         components << prefix
@@ -231,8 +258,8 @@ class Person < ApplicationRecord
 
   def add_address(address_line, label="Home")
     if self != self.class.find_by_address(address_line)
-      a = Address.parse(address_line);
-      a.addressable_type = self.class.name;
+      a = Address.parse(address_line)
+      a.addressable_type = self.class.name
       a.label = Label.get(label)
       a.save
       addresses << a
@@ -240,5 +267,10 @@ class Person < ApplicationRecord
     a = Address.find_by_address(address_line)
   end
 
-
+  def as_api_json(options={})
+    candidate = self.as_json(options)
+    candidate[:emails] = self.emails.collect {|e| { label: e.label, address: e.address }}
+    candidate[:addresses] = self.addresses.collect {|a| { label: a.label, address: a.address }}
+    candidate
+  end
 end

data/app/models/phone.rb

@@ -1,18 +1,23 @@
+require "phony_rails"
+
 class Phone < ApplicationRecord
-  belongs_to :label, optional: true
-  belongs_to :phoneable, polymorphic: true
+  include Labelize
+  belongs_to :phoneable, polymorphic: true, optional: true
   before_validation :canonicalize
 
   def self.canonicalize(digits_and_stuff)
-    canonical = digits_and_stuff
-    canonical.gsub!(" ", "") #remove extra spaces
+    canonical = digits_and_stuff.gsub(" ", "")
     if canonical
       canonical = canonical[2..100].strip if canonical.starts_with?("+1")
-      if canonical[0] != "+"
-        digits = digits_and_stuff.gsub(/[^0-9]/, "")
-        digits = digits[1..-1] if digits[0] == '1'
-        digits = "805" + digits if digits.length == 7
-        canonical = "(#{digits[0..2]}) #{digits[3..5]}-#{digits[6..10]}"
+      if self.const_defined?("PhonyRails")
+        canonical = PhonyRails.normalize_number(digits_and_stuff, default_country_code: "US").phony_formatted(format: :international)
+      else
+        if canonical[0] != "+"
+          digits = digits_and_stuff.gsub(/[^0-9]/, "")
+          digits = digits[1..-1] if digits[0] == '1'
+          digits = "805" + digits if digits.length == 7
+          canonical = "(#{digits[0..2]}) #{digits[3..5]}-#{digits[6..10]}"
+        end
       end
     end
     canonical
@@ -23,4 +28,18 @@ class Phone < ApplicationRecord
     self.number = self.class.canonicalize(self.number) if self.number
   end
 
+  def label
+    db_label = super
+    if not db_label
+      self.label = "Work"
+      db_label = super
+    end
+
+    db_label.value
+  end
+
+  def label=(name)
+    super(Label.get(name))
+    self.label
+  end
 end

data/app/models/user.rb

@@ -1,25 +1,18 @@
 class User < ApplicationRecord
   belongs_to :person
   accepts_nested_attributes_for :person
-  has_many :credentials, as: :credentialed, dependent: :destroy
-  accepts_nested_attributes_for :credentials
   has_and_belongs_to_many :organizations
 
-  delegate :name, :name=, to: :person
-  delegate :fname, :fname=, to: :person
-  delegate :lname, :lname, to: :person
-  delegate :minitial, :minitial, to: :person
-  delegate :prefix, :prefix, to: :person
-  delegate :suffix, :suffix, to: :person
-  delegate :emails, :emails=, :email, :email=, to: :person
-  delegate :phones, :phones=, :phone, :phone=, to: :person
-  delegate :addresses, :addresses=, :address, :address=, to: :person
-  delegate :birthdate, :birthdate=, to: :person
-  delegate :age, :age=, to: :person
+  PERSON_ATTR = %w(name fname lname minitial prefix suffix email phone emails phones addresses birthdate age nationality language)
+  PERSON_SYMS = PERSON_ATTR.collect {|x| [x.to_sym, (x + "=").to_sym] }.flatten
+  PERSON_SET  = PERSON_SYMS + PERSON_ATTR
+  
+  delegate(*PERSON_SYMS, to: :person)
   
   def self.lookup(item)
     person = Person.lookup(item)
-    (person.send self.name.downcase.to_sym) if person
+    this_class = self.name.downcase.to_sym
+    (person.send this_class) if person and person.respond_to?(this_class)
   end
 
   def organization=(org)
@@ -29,4 +22,11 @@ class User < ApplicationRecord
   def organization
     self.organizations.order(created_at: :desc).first
   end
+ 
+  def assign_attributes(attr)
+    if not attr.keys.to_set.intersection(PERSON_SET).empty?
+      self.person = Person.new
+    end
+    super(attr)
+  end
 end

data/db/migrate/00000000000005_create_people.rb

@@ -8,6 +8,7 @@ class CreatePeople < ActiveRecord::Migration[5.2]
       t.string :suffix, limit: 10
       t.string :birthdate
       t.string :nationality
+      t.string :language, limit: 10
 
       t.timestamps
     end

data/db/seeds.rb

@@ -4,5 +4,4 @@ bfox = User.lookup("bfox@opuslogica.com") ||
        User.create(person_attributes: { email: "bfox@opuslogica.com", name: "Brian Jhan Fox",
                                         address: "901 Olive St., Santa Barbara, CA, 93101",
                                         phone: "805.555.8642" },
-                   organization: opus,
-                   credentials_attributes: [{ password: "idtmp2tv" }])
+                   organization: opus)

data/lib/openopus/core/people/engine.rb

@@ -2,7 +2,6 @@ module Openopus
   module Core
     module People
       class Engine < ::Rails::Engine
-        isolate_namespace People
         initializer :append_migrations do |app|
           unless app.root.to_s.match(root.to_s)
             config.paths["db/migrate"].expanded.each do |expanded_path|

data/lib/openopus/core/people/version.rb

@@ -1,7 +1,7 @@
 module Openopus
   module Core
     module People
-      VERSION = '1.1.0'
+      VERSION = '1.1.11'
     end
   end
 end

data/lib/tasks/openopus/core/people/tasks.rake

@@ -0,0 +1,44 @@
+namespace :openopus do
+  namespace :core do
+    namespace :people do
+      desc "Generate one or many random people in your database. Requires 'gem rest-client'. Only for testing!"
+      task :generate_people, [:count] => :environment do |task, args|
+        def generate_person
+          json = ActiveSupport::HashWithIndifferentAccess.new(JSON(RestClient::Request.execute(method: :get, url: 'https://randomuser.me/api?format=json&nat=US').body))
+          jp = json[:results][0]
+          l = jp[:location]
+          a = Address.new
+          a.line1 = l[:street].titleize; a.city = l[:city].titleize; a.state = l[:state].titleize;
+          a.postal = l[:postcode].to_s.upcase; a.country = "US"
+          name = jp[:name]
+          p = Person.create(name: "#{name[:title]} #{name[:first]} #{name[:last]}".titleize,
+                            phone: jp[:phone], address: a, email: jp[:email],
+                            birthdate: jp[:dob][:date], nationality: jp[:nat])
+          p.picture = jp[:picture][:medium] if p.respond_to?("picture=".to_sym)
+          p.photo = jp[:picture][:medium] if p.respond_to?("photo=".to_sym)
+          p
+        end
+
+        count = args[:count]
+        count ||= 1
+        count.to_i.times do
+          person = generate_person
+          puts("openopus made: #{person.name} of #{person.address.oneline}")
+        end
+      end
+
+      desc "Generate users from the people in your database that aren't associated with any user. Only for testing!"
+      task :generate_users, [:count] => :environment do |task, args|
+        def generate_user(person)
+          user = User.create(person_id: person.id, status: "generated") if not person.user and not person.email.blank?
+          if user and user.respond_to?(:credentials) and user.credentials.blank?
+            user.credentials.create(password: "password")
+          end
+        end
+
+        Rake::Task["openopus:core:people:generate_people"].invoke(args[:count]) if not args[:count].blank?
+        Person.all.each { |person| generate_user(person) }
+      end
+    end
+  end
+end

metadata

@@ -1,27 +1,27 @@
 --- !ruby/object:Gem::Specification
 name: openopus-core-people
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.1.11
 platform: ruby
 authors:
 - Brian J. Fox
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-07-13 00:00:00.000000000 Z
+date: 2020-12-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">"
       - !ruby/object:Gem::Version
         version: 5.2.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">"
       - !ruby/object:Gem::Version
         version: 5.2.3
 - !ruby/object:Gem::Dependency
@@ -38,6 +38,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 3.1.13
+- !ruby/object:Gem::Dependency
+  name: phony_rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '0.14'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '0.14'
 description: A person can have many email addresses, but this is not usually represented
   in applications.  openopus/core/people creates the database structure, relations,
   and convenience functions for your application so you don't have to.  Just connect
@@ -53,7 +67,7 @@ files:
 - Rakefile
 - app/assets/config/openopus_core_people_manifest.js
 - app/models/address.rb
-- app/models/credential.rb
+- app/models/concerns/labelize.rb
 - app/models/email.rb
 - app/models/label.rb
 - app/models/nickname.rb
@@ -70,14 +84,13 @@ files:
 - db/migrate/00000000000005_create_people.rb
 - db/migrate/00000000000006_create_organizations.rb
 - db/migrate/00000000000007_create_users.rb
-- db/migrate/00000000000008_create_credentials.rb
 - db/migrate/00000000000009_create_join_table_organizations_users.rb
 - db/seeds.rb
 - lib/openopus/core/people.rb
 - lib/openopus/core/people/engine.rb
 - lib/openopus/core/people/version.rb
-- lib/tasks/openopus/core/people_tasks.rake
-homepage: https://github.com/opuslogica/openopus-core-people
+- lib/tasks/openopus/core/people/tasks.rake
+homepage: https://github.com/openopus/openopus-core-people
 licenses:
 - MIT
 metadata:
@@ -97,7 +110,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.1
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Model the real world of people in your application, making user interaction

data/app/models/credential.rb

@@ -1,15 +0,0 @@
-class Credential < ApplicationRecord
-  has_secure_password
-  belongs_to :credentialed, polymorphic: true
-
-  # We point to an enail that actually polymorphically belongs to a different thing.
-  # Which is great.  So don't declare this to be a polymorphic relationship.  It isn't.
-  belongs_to :email
-  before_validation :grab_email_from_credentialed
-
-  # validates :password, length: { minimum: 8 }, on: :create
-
-  def grab_email_from_credentialed
-    self.email ||= self.credentialed.email
-  end
-end

data/db/migrate/00000000000008_create_credentials.rb

@@ -1,13 +0,0 @@
-class CreateCredentials < ActiveRecord::Migration[5.2]
-  def change
-    create_table :credentials do |t|
-      t.references :credentialed, polymorphic: true
-      t.references :email, foreign_key: true
-      t.string :password_digest
-      t.string :provider                # Like Google, Facebook, etc.
-      t.string :provider_auth           # Whatever their auth token looks like.
-
-      t.timestamps
-    end
-  end
-end

data/lib/tasks/openopus/core/people_tasks.rake

@@ -1,4 +0,0 @@
-# desc "Explaining what the task does"
-# task :openopus_core_people do
-#   # Task goes here
-# end