Module: Gluttonberg::Membership::Import::PrivateMethods

Defined in:
lib/gluttonberg/membership/import.rb

Overview

ClassMethods

Class Method Summary collapse

Class Method Details

.attach_user_to_group(user_info, row, known_columns, other_columns, group_ids) ⇒ Object 



118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
 
# File 'lib/gluttonberg/membership/import.rb', line 118

def self.attach_user_to_group(, row, known_columns, other_columns, group_ids)
  unless known_columns[:groups].blank? || row[known_columns[:groups]].blank?
    group_names = row[known_columns[:groups]].split(";")
    temp_group_ids = []
    group_names.each do |group_name|
      group = Gluttonberg::Group.where(:name => group_name.strip).first
      temp_group_ids << group.id unless group.blank?
    end
    [:group_ids] = temp_group_ids
  end

  unless group_ids.blank?
    if [:group_ids].blank?
      [:group_ids] = group_ids
    else
      [:group_ids] << group_ids
    end
  end
  
end

.create_member(user_info, invite, row, successfull_users, failed_users, updated_users) ⇒ Object 



151
152
153
154
155
156
157
158
159
160
161
162
163
164
 
# File 'lib/gluttonberg/membership/import.rb', line 151

def self.create_member(, invite, row, successfull_users , failed_users , updated_users)
  user = PrivateMethods.prepare_user_record(, row)
  #if its valid then save it send an email and also add it to successfull_users array
  if user.valid?
    user.save
    if invite == "1"
      # we will regenerate password and send it member
      MemberNotifier.delay.welcome(user)
    end
    successfull_users << user
  else # if failed then add it to failed list
    failed_users << user
  end
end

.find_column_position(csv_table, col_name) ⇒ Object

csv_table is two dimentional array col_name is a string. if structure is proper and column name found it returns column index from 0 to n-1 otherwise nil



66
67
68
69
70
71
72
73
 
# File 'lib/gluttonberg/membership/import.rb', line 66

def self.find_column_position(csv_table  , col_name)
  if csv_table.instance_of?(Array) && csv_table.count > 0 && csv_table.first.count > 0
    csv_table.first.each_with_index do |table_col , index|
      return index if table_col.to_s.upcase == col_name.to_s.upcase
    end
  end
  nil
end

.find_known_columns(csv_table) ⇒ Object 



75
76
77
78
79
80
81
82
 
# File 'lib/gluttonberg/membership/import.rb', line 75

def self.find_known_columns(csv_table)
  known_columns = {}
  known_columns[:first_name]  = find_column_position(csv_table , Rails.configuration.member_csv_metadata[:first_name] )
  known_columns[:last_name]   = find_column_position(csv_table ,  Rails.configuration.member_csv_metadata[:last_name]  )
  known_columns[:email]       = find_column_position(csv_table , Rails.configuration.member_csv_metadata[:email] )
  known_columns[:groups]      = find_column_position(csv_table , Rails.configuration.member_csv_metadata[:groups] )
  known_columns
end

.find_other_columns(csv_table) ⇒ Object 



84
85
86
87
88
89
90
91
92
 
# File 'lib/gluttonberg/membership/import.rb', line 84

def self.find_other_columns(csv_table)
  other_columns = {}
  Rails.configuration.member_csv_metadata.each do |key , val|
    if ![:first_name, :last_name , :email, :groups].include?(key)
      other_columns[key] = find_column_position(csv_table , val )
    end
  end
  other_columns
end

.known_columns_valid?(known_columns) ⇒ Boolean

Returns:

  • (Boolean) 


114
115
116
 
# File 'lib/gluttonberg/membership/import.rb', line 114

def self.known_columns_valid?(known_columns)
  known_columns[:first_name] && known_columns[:email]
end

.prepare_user_record(user_info, row) ⇒ Object

attr_user_to_group



139
140
141
142
143
144
145
146
147
148
149
 
# File 'lib/gluttonberg/membership/import.rb', line 139

def self.prepare_user_record(, row)
  # generate random password
  temp_password = Gluttonberg::Member.generateRandomString
  password_hash = {
    :password => temp_password ,
    :password_confirmation => temp_password
  }

  # make user object
  Gluttonberg::Member.new(.merge(password_hash))
end

.read_data_row(row, known_columns, other_columns) ⇒ Object 



94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
# File 'lib/gluttonberg/membership/import.rb', line 94

def self.read_data_row(row, known_columns, other_columns)
   = {
    :group_ids => []
  }
  [:first_name] = row[known_columns[:first_name]] unless Rails.configuration.member_csv_metadata[:first_name].blank? 
  [:last_name] = row[known_columns[:last_name]]  unless Rails.configuration.member_csv_metadata[:last_name].blank?
  [:email] = row[known_columns[:email]]  unless Rails.configuration.member_csv_metadata[:email].blank?

  other_columns.each do |key , val|
    if !val.blank? && val >= 0
      if row[val].blank? || ![key].kind_of?(String)
        [key] = row[val]
      else
        [key] = row[val].force_encoding("UTF-8")
      end
    end
  end
  
end

.update_member(user, user_info, successfull_users, failed_users, updated_users) ⇒ Object 



166
167
168
169
170
171
172
173
174
 
# File 'lib/gluttonberg/membership/import.rb', line 166

def self.update_member(user, , successfull_users , failed_users , updated_users)
  if !Gluttonberg::Member.contains_user?(user , successfull_users) and !Gluttonberg::Member.contains_user?(user , updated_users)
    if user.update_attributes()
      updated_users << user
    else
      failed_users << user
    end
  end
end