openopus-core-people 1.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: fb6c5d918b4cf8dc73c3c5a22503673dc1ddf9558a8447ef1a505154007753d9
+  data.tar.gz: e749bc852fe3e432d4aae6e3ce33c04135a94fca16cda43c2ccaecc25b3e0942
+SHA512:
+  metadata.gz: 5abc7901b229c1850154f628bb6c6efe47bfe3e39ebbf45c0e7d49c4a9286f48c5a1b48af70aaff01fe40ce85d1a148b9f166e83c90fbf371f0eb816aa5f252c
+  data.tar.gz: 9c08ec78f0de97a8e880295e6e01a7db12471371c59c6db043533986d041bef2317fdbee48c7ba6c78a6c1317a6fca432a5641ee75e04d828efdc959ff8c43f9

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2019 Brian J. Fox
+
+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

@@ -0,0 +1,38 @@
+# Openopus::Core::People
+Model the real world of people in your application, making user interaction robust. By way of example, 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 your end user model, and away you go.
+
+## Usage
+Install the gem, run migrations.  This will create human structures, from Organization down to people (Person).  More documentation and usage examples will be forthcoming.
+
+```ruby
+  opus = Organization.where(name: "Opus Logica, Inc").first_or_create(nicknames_attributes: [{ nickname: "OPUS" }])
+  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" }])
+```
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'openopus-core-people', git: "https://github.com/opuslogica/openopus-core-people"
+```
+
+And then execute:
+```bash
+$ bundle install
+$ bundle exec rake db:migrate
+```
+
+Or install it yourself as:
+```bash
+$ gem install openopus-core-people
+```
+
+## Contributing
+Got an idea for an improvement?  Think this thing is *almost* good, but still kinda sucks?  Create an issue, and we'll get back to you ASAP.  Please discuss code contributions with us before hand so that we can agree on the architecture.  Otherwise, we might not be able to take your improvements.
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,32 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Openopus::Core::People'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("test/dummy/Rakefile", __dir__)
+load 'rails/tasks/engine.rake'
+
+load 'rails/tasks/statistics.rake'
+
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task default: :test

data/app/models/address.rb

@@ -0,0 +1,168 @@
+class Address < ApplicationRecord
+  belongs_to :label, optional: true
+  belongs_to :addressable, polymorphic: true
+
+  accepts_nested_attributes_for :label
+  
+#  require 'carmen'
+#  require 'geocoder'
+#  geocoded_by :oneline, latitude: :lat, longitude: :lon
+#  after_validation :geocode
+
+  def address
+    oneline
+  end
+
+  def save(options={})
+    r = super(options)
+    @already_geocoded = false
+    r
+  end
+
+  def assign_attributes(hash)
+    if hash.has_key?('address')
+      a = hash['address']
+      hash.delete('address')
+    end
+    super(hash)
+    self.address = a if a
+    nil
+  end
+
+  def label=(text_or_label)
+    l   = Label.get(text_or_label.to_s) if text_or_label.is_a?(String) or text_or_label.is_a?(Symbol)
+    l ||= text_or_label
+    write_attribute(:label_id, l.id)
+  end
+
+  def update_lat_lon(info=nil)
+    info ||= Geocoder.search(self.oneline).first rescue nil
+    if info
+      if info.respond_to?(:latitude)
+        self.lat = info.latitude
+        self.lon = info.longitude
+      else
+        self.lat = info.geometry["location"]["lat"] rescue nil
+        self.lon = info.geometry["location"]["lng"] rescue nil
+      end
+    end
+  end
+
+  def address=(string)
+    return unless not string.blank? and not postal_changed?
+    return unless string != line1
+    return if (string == oneline() || string == oneline({full: true}))
+
+    have_geocoder = defined?(Geocoder)
+    r = Geocoder.search(string) rescue nil
+    @already_geocoded = true
+    
+    if not r or r.length == 0
+      self.errors.add(:address, :did_not_geocode, message: "No locations found") if have_geocoder
+      self.line1 = string
+    else
+      res = r[0]
+      self.update_lat_lon(res)
+      if res.respond_to?(:street)
+        self.line1 = (res.house_number ? res.house_number + " " : "") + res.street
+        self.line2 = nil
+        c = Carmen::Country.coded(res.country_code) rescue nil
+        s = c.subregions.named(res.state) if c
+        self.state = s.code.to_s if s
+      else
+        self.line1 = res.street_address.to_s rescue string
+        self.line2 = nil
+        self.state = res.state_code.to_s
+      end
+        self.city = res.city.to_s
+        self.postal = res.postal_code.to_s
+        self.country = res.country_code.to_s.upcase
+    end
+
+    self.errors.add(:address, :too_many_matches, message: "Too many matches") if have_geocoder && r && r.length > 1 
+    self
+  end
+
+  def self.find_by_address(string)
+    template = self.parse(string)
+    self.find_by(template.attributes.symbolize_keys!.slice(:line1, :line2, :city, :state))
+  end
+  
+  def as_json(options={})
+    for_user = options.delete(:for_user)
+    res = super(options)
+    res[:address] = oneline
+    res[:label] = self.label.value if self.label
+    res
+  end
+
+  def update_from_postal
+    return if @already_geocoded or self.postal.blank?
+    r = Geocoder.search(self.postal) rescue nil
+    if not r or r.length == 0
+      return
+      self.errors.add(:postal, :cannot_locate_postal_code, message: "Couldn't locate postal code")
+    else
+      res = r[0]
+      self.update_lat_lon(res)
+      self.city = res.city
+      self.state = res.state_code
+      self.country = res.country_code
+    end
+  end
+
+  def oneline(options={})
+    if options[:full]
+      return [line1, line2, city, state, postal].compact.join(", ").gsub(/, ,/, ",")
+    else
+      return "#{line1}, #{city}, #{state}"
+    end
+  end
+
+  def self.parse(string)
+    a = self.new
+    a.address = string
+    a
+  end
+
+  def self.new_from_hash(incoming_hash)
+    p = {}
+    incoming_hash.each {|key, val| p[key] = val if not val.blank?}
+    a = self.new
+    a.line1 = p[:line1] || p[:address]
+    a.line2 = p[:line2]
+    a.city = p[:city]
+    a.state = p[:state]
+    a.country = p[:country]
+    a.postal = p[:postal] || p[:zipcode] || p[:zip]
+    a.label = Label.get("Work")
+    a
+  end
+
+  def self.find_or_create_by_example(other)
+    res = self
+    res = res.where(:line1 => other.line1) if other.line1
+    res = res.where(:line2 => other.line2) if other.line2
+    res = res.where(:city => other.city) if other.city
+    res = res.where(:state => other.state) if other.state
+    res = res.where(:country => other.country) if other.country
+    res = res.where(:postal => other.postal) if other.postal
+
+    a = nil
+    addresses = res
+    if addresses != self
+      a = Address.create(other.attributes.symbolize_keys!.except(:id, :created_at, :updated_at)) if addresses == []
+      a ||= addresses[0]
+    end
+
+    a
+  end
+
+  def admin_object_name
+    [line1, city, postal].join(" ").strip rescue ""
+  end
+
+  def person
+    self.people.first rescue nil
+  end
+end

data/app/models/credential.rb

@@ -0,0 +1,15 @@
+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/app/models/email.rb

@@ -0,0 +1,19 @@
+class Email < ApplicationRecord
+  belongs_to :label, optional: true
+  belongs_to :emailable, polymorphic: true
+  accepts_nested_attributes_for :label
+  before_create :default_label
+
+  def self.canonicalize(addr)
+    addr.strip.downcase if not addr.blank?
+  end
+
+  def canonicalize
+    self.address = self.class.canonicalize(self.address)
+  end
+
+  def default_label
+    self.label = Label.get("Work")
+  end
+
+end

data/app/models/label.rb

@@ -0,0 +1,11 @@
+class Label < ApplicationRecord
+
+  def self.instantiate_defaults
+    %w(Home Work Cell).each {|v| self.get(v)}
+  end
+
+  def self.get(name, lang="en")
+    self.where(value: name, lang: lang).first_or_create
+  end
+
+end

data/app/models/nickname.rb

@@ -0,0 +1,3 @@
+class Nickname < ApplicationRecord
+  belongs_to :nicknameable, polymorphic: true
+end

data/app/models/organization.rb

@@ -0,0 +1,12 @@
+class Organization < ApplicationRecord
+  has_many :nicknames, as: :nicknameable
+  accepts_nested_attributes_for :nicknames
+  has_and_belongs_to_many :users
+  accepts_nested_attributes_for :users
+
+  def self.lookup(thing)
+    candidate   = self.where(name: thing).first
+    candidate ||= self.includes(:nicknames).joins(:nicknames).find_by("nicknames.nickname" => thing)
+  end
+
+end

data/app/models/person.rb

@@ -0,0 +1,244 @@
+class Person < ApplicationRecord
+  has_many :users
+  has_many :nicknames, as: :nicknameable
+  has_many :addresses, as: :addressable
+  has_many :phones, as: :phoneable
+  has_many :emails, as: :emailable
+
+  accepts_nested_attributes_for :nicknames
+  accepts_nested_attributes_for :addresses
+  accepts_nested_attributes_for :phones
+  accepts_nested_attributes_for :emails
+
+  def self.lookup(name)
+    person   = self.find_by(self.name_components(name))
+    person ||= self.includes(:nicknames).joins(:nicknames).find_by("nicknames.nickname" => name)
+    if not person
+      people = self.all.collect do |p|
+        [p.id, [(p.fname[0] || ""), (p.minitial[0] || ""), (p.lname[0] || "")].join("").upcase]
+      end
+      people.each do |parry|
+        if parry[1] == name.upcase
+          person = self.find(parry[0])
+          break
+        end
+      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
+
+  def user
+    self.users.first
+  end
+
+  def user=(u)
+    self.users = [u]
+  end
+
+  def email
+    self.emails.first
+  end
+
+  def email=(address)
+    e = self.emails.where(address: Email.canonicalize(address)).first_or_initialize() if not address.blank?
+    self.emails << e if not emails.include?(e)
+    e
+  end
+    
+  def phone
+    p = self.phones.find_by(label: Label.get("Work"))
+    p ||= self.phones.first
+    p
+  end
+
+  def phone=(number)
+    if number.is_a?(Phone)
+      self.phones << number unless self.phones.include?(number)
+      return
+    end
+
+    if not number.blank?
+      p = self.phones.first rescue nil
+      p ||= Phone.create(phoneable_type: self.class.name, label: Label.get("Work"))
+      self.phones << p unless self.phones.include?(p)
+      p.number = number
+      p.save
+    end
+  end
+
+  def self.is_name_prefix?(text)
+    possibles = %w(mr mrs ms miss dr professor prof)
+    result = possibles.include?(text.gsub(/[.]*/, "").downcase) if text.present?
+  end
+
+  def self.is_name_suffix?(text)
+    possibles = %w(esq phd jr iii ii)
+    result = possibles.include?(text.gsub(/[.]*/, "").downcase) if text.present?
+  end
+
+  def self.name_components(name)
+    res = {}
+    component = ""
+    components = name.gsub(/,/, " ").gsub(/  /, " ").split(" ") rescue [name]
+    num_parts = components.length
+    component = components.shift
+
+    # What kind of thing is this?
+    if is_name_prefix?(component)
+      res[:prefix] = component
+      res[:fname] = components.shift
+    else
+      res[:fname] = component
+    end
+
+    # 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
+    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[:lname] = components.shift
+      else
+        res[:lname] = component
+      end
+      res[:minitial] = components.shift
+    end
+
+    res[:minitial] = res[:minitial].gsub(/[.]/, "") if res[:minitial].present?
+    res
+  end
+
+  def name
+    components = []
+
+    if prefix.present?
+      if not prefix.include?(".")
+        components << "#{prefix}."
+      else
+        components << prefix
+      end
+    end
+
+    components << self.fname if self.fname.present?
+
+    if minitial.present?
+      if minitial.length < 2
+        components << "#{minitial}."
+      else
+        components << minitial
+      end
+    end
+
+    components << self.lname if self.lname.present?
+    components << ", #{suffix}" if self.suffix.present?
+    components.join(" ").strip.gsub(/ ,/, ",")
+  end
+
+  def name=(incoming_name)
+    components = self.class.name_components(incoming_name)
+    self.prefix = components[:prefix]
+    self.fname = components[:fname]
+    self.minitial = components[:minitial]
+    self.lname = components[:lname]
+    self.suffix = components[:suffix]
+  end
+
+  def age
+    ((Date.today - self.birthdate).to_i / 365) if self.birthdate.present?
+  end
+
+  def age=(new_age)
+    self.birthdate = (Date.today - (rand(Date.today.month - 1))) - new_age.years
+    self.birthdate
+  end
+
+  def address
+    a = self.addresses.where(label: Label.get("Work")).first
+    a ||= self.addresses.first
+  end
+
+  def address=(new_address)
+    candidate = nil
+    if new_address.is_a?(Address)
+      candidate = new_address
+    elsif %w(Integer Fixnum Bignum).include?(new_address.class.to_s)
+      candidate = Address.find(new_address)
+    else
+      parsed = Address.parse(new_address)
+      candidate = self.addresses.where(line1: parsed.line1).first
+      candidate ||= Address.new
+      parsed.attributes.each {|key, val| candidate.send((key + "=").to_sym, val) unless val == nil }
+      candidate.save
+    end
+    self.addresses << candidate unless self.addresses.include?(candidate)
+    self.save
+  end
+
+  def self.find_or_create_by(hash)
+    options = hash.clone
+    if options.has_key?(:name)
+      options = options.merge(self.name_components(options[:name]))
+      options.delete(:name)
+    end
+    super(options)
+  end
+
+  def self.find_by_nickname(nick)
+    person = self.includes(:nicknames).joins(:nicknames).find_by("nicknames.nickname" => nick)
+  end
+
+  def self.find_by_email(addr)
+    e = Email.where(address: Email.canonicalize(addr), emailable_type: self.name)
+    e.person if e
+  end
+
+  def self.find_by_phone_number(number)
+    p = Phone.where(number: Phone.canonicalize(number), phoneable_type: self.name)
+    p.person if p
+  end
+
+  def self.find_by_address(string)
+    a = Address.find_by_address(string)
+    a.person if a and a.addressable_type == self.name
+  end
+
+  def add_phone(number, label="Home")
+    if self != self.class.find_by_phone_number(number)
+      p = Phone.create(number: number, phoneable_type: self.class.name, label: Label.get(label))
+      phones << p
+    end
+    p = Phone.where(number: Phone.canonicalize(number), phoneable_type: self.class.name)
+  end
+
+  def add_email(address, label="Home")
+    address = Email.canonicalize(address)
+    if self != self.class.find_by_email(address)
+      e = Email.create(address: address, emailable_type: self.class.name, label: Label.get(label))
+      emails << e
+    end
+    e = Email.where(address:address, emailable_type: self.class.name)
+  end
+
+  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.label = Label.get(label)
+      a.save
+      addresses << a
+    end
+    a = Address.find_by_address(address_line)
+  end
+
+
+end

data/app/models/phone.rb

@@ -0,0 +1,26 @@
+class Phone < ApplicationRecord
+  belongs_to :label, optional: true
+  belongs_to :phoneable, polymorphic: true
+  before_validation :canonicalize
+
+  def self.canonicalize(digits_and_stuff)
+    canonical = digits_and_stuff
+    canonical.gsub!(" ", "") #remove extra spaces
+    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]}"
+      end
+    end
+    canonical
+  end
+
+  def canonicalize
+    return if self.number == "76-BAFFLE-76"
+    self.number = self.class.canonicalize(self.number) if self.number
+  end
+
+end

data/app/models/user.rb

@@ -0,0 +1,32 @@
+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
+  
+  def self.lookup(item)
+    person = Person.lookup(item)
+    (person.send self.name.downcase.to_sym) if person
+  end
+
+  def organization=(org)
+    self.organizations << org if not self.organizations.include?(org)
+  end
+
+  def organization
+    self.organizations.order(created_at: :desc).first
+  end
+end

data/config/routes.rb

@@ -0,0 +1,2 @@
+Rails.application.routes.draw do
+end

data/db/migrate/00000000000000_create_labels.rb

@@ -0,0 +1,10 @@
+class CreateLabels < ActiveRecord::Migration[5.2]
+  def change
+    create_table :labels do |t|
+      t.string :value
+      t.string :lang
+
+      t.timestamps
+    end
+  end
+end

data/db/migrate/00000000000001_create_nicknames.rb

@@ -0,0 +1,9 @@
+class CreateNicknames < ActiveRecord::Migration[5.2]
+  def change
+    create_table :nicknames do |t|
+      t.string :nickname
+      t.references :nicknameable, polymorphic: true
+      t.timestamps
+    end
+  end
+end

data/db/migrate/00000000000002_create_addresses.rb

@@ -0,0 +1,19 @@
+class CreateAddresses < ActiveRecord::Migration[5.2]
+  def change
+    create_table :addresses do |t|
+      t.references :label, foreign_key: true
+      t.references :addressable, polymorphic: true
+      t.string :line1
+      t.string :line2
+      t.string :city
+      t.string :state
+      t.string :postal
+      t.string :country
+      t.float :lat
+      t.float :lon
+      t.boolean :confirmed
+
+      t.timestamps
+    end
+  end
+end

data/db/migrate/00000000000003_create_phones.rb

@@ -0,0 +1,12 @@
+class CreatePhones < ActiveRecord::Migration[5.2]
+  def change
+    create_table :phones do |t|
+      t.references :label, foreign_key: true
+      t.references :phoneable, polymorphic: true
+      t.string :number
+      t.boolean :confirmed
+
+      t.timestamps
+    end
+  end
+end

data/db/migrate/00000000000004_create_emails.rb

@@ -0,0 +1,12 @@
+class CreateEmails < ActiveRecord::Migration[5.2]
+  def change
+    create_table :emails do |t|
+      t.references :label, foreign_key: true
+      t.references :emailable, polymorphic: true
+      t.string :address
+      t.boolean :confirmed
+
+      t.timestamps
+    end
+  end
+end

data/db/migrate/00000000000005_create_people.rb

@@ -0,0 +1,15 @@
+class CreatePeople < ActiveRecord::Migration[5.2]
+  def change
+    create_table :people do |t|
+      t.string :prefix, limit: 10
+      t.string :fname
+      t.string :minitial
+      t.string :lname
+      t.string :suffix, limit: 10
+      t.string :birthdate
+      t.string :nationality
+
+      t.timestamps
+    end
+  end
+end

data/db/migrate/00000000000006_create_organizations.rb

@@ -0,0 +1,10 @@
+class CreateOrganizations < ActiveRecord::Migration[5.2]
+  def change
+    create_table :organizations do |t|
+      t.string :name
+      t.string :nationality
+
+      t.timestamps
+    end
+  end
+end

data/db/migrate/00000000000007_create_users.rb

@@ -0,0 +1,10 @@
+class CreateUsers < ActiveRecord::Migration[5.2]
+  def change
+    create_table :users do |t|
+      t.references :person, foreign_key: true
+      t.string :status
+
+      t.timestamps
+    end
+  end
+end

data/db/migrate/00000000000008_create_credentials.rb

@@ -0,0 +1,13 @@
+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/db/migrate/00000000000009_create_join_table_organizations_users.rb

@@ -0,0 +1,8 @@
+class CreateJoinTableOrganizationsUsers < ActiveRecord::Migration[5.2]
+  def change
+    create_join_table :organizations, :users do |t|
+      # t.index [:organization_id, :user_id]
+      # t.index [:user_id, :organization_id]
+    end
+  end
+end

data/db/seeds.rb

@@ -0,0 +1,8 @@
+# coding: utf-8
+opus = Organization.where(name: "Opus Logica, Inc").first_or_create(nicknames_attributes: [{ nickname: "OPUS" }])
+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" }])

data/lib/openopus/core/people.rb

@@ -0,0 +1,9 @@
+require "openopus/core/people/engine"
+
+module Openopus
+  module Core
+    module People
+      # Your code goes here...
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+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|
+              app.config.paths["db/migrate"] << expanded_path
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

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

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: openopus-core-people
+version: !ruby/object:Gem::Version
+  version: 1.1.0
+platform: ruby
+authors:
+- Brian J. Fox
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-07-13 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
+  name: bcrypt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.1.13
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.1.13
+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
+  your end user model, and away you go.
+email:
+- bfox@opuslogica.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- app/assets/config/openopus_core_people_manifest.js
+- app/models/address.rb
+- app/models/credential.rb
+- app/models/email.rb
+- app/models/label.rb
+- app/models/nickname.rb
+- app/models/organization.rb
+- app/models/person.rb
+- app/models/phone.rb
+- app/models/user.rb
+- config/routes.rb
+- db/migrate/00000000000000_create_labels.rb
+- db/migrate/00000000000001_create_nicknames.rb
+- db/migrate/00000000000002_create_addresses.rb
+- db/migrate/00000000000003_create_phones.rb
+- db/migrate/00000000000004_create_emails.rb
+- 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
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.1
+signing_key: 
+specification_version: 4
+summary: Model the real world of people in your application, making user interaction
+  robust.
+test_files: []