inkwell 1.2.0 → 1.4.1

data/app/models/inkwell/community_user.rb

@@ -0,0 +1,15 @@
+module Inkwell
+  if ::Inkwell::Engine::config.respond_to?('community_table')
+    class CommunityUser < ActiveRecord::Base
+      attr_accessible "#{::Inkwell::Engine::config.user_table.to_s.singularize}_id", "#{::Inkwell::Engine::config.community_table.to_s.singularize}_id",
+                      :is_writer, :is_admin, :admin_level, :muted, :user_access, :active, :banned, :asked_invitation
+      belongs_to ::Inkwell::Engine::config.community_table.to_s.singularize.to_sym
+      belongs_to ::Inkwell::Engine::config.user_table.to_s.singularize.to_sym
+      belongs_to :admins, :foreign_key => "#{::Inkwell::Engine::config.user_table.to_s.singularize}_id"
+      belongs_to :writers, :foreign_key => "#{::Inkwell::Engine::config.user_table.to_s.singularize}_id"
+      belongs_to :muted_users, :foreign_key => "#{::Inkwell::Engine::config.user_table.to_s.singularize}_id"
+      belongs_to :banned_users, :foreign_key => "#{::Inkwell::Engine::config.user_table.to_s.singularize}_id"
+      belongs_to :asked_invitation_users, :foreign_key => "#{::Inkwell::Engine::config.user_table.to_s.singularize}_id"
+    end
+  end
+end

data/app/models/inkwell/following.rb

@@ -0,0 +1,8 @@
+module Inkwell
+  class Following < ActiveRecord::Base
+    attr_accessible :followed_id, :follower_id
+
+    belongs_to :following, :foreign_key => :followed_id
+    belongs_to :follower, :foreign_key => :follower_id
+  end
+end

data/db/migrate/20130212130888_refactor_followings_relation.rb

@@ -0,0 +1,27 @@
+class RefactorFollowingsRelation < ActiveRecord::Migration
+  def change
+    create_table :inkwell_followings do |t|
+      t.integer :follower_id
+      t.integer :followed_id
+
+      t.timestamps
+    end
+    add_column ::Inkwell::Engine::config.user_table, :follower_count, :integer, :default => 0
+    add_column ::Inkwell::Engine::config.user_table, :following_count, :integer, :default => 0
+
+    user_class = Object.const_get ::Inkwell::Engine::config.user_table.to_s.singularize.capitalize
+    user_class.all.each do |user|
+      followings_ids = ActiveSupport::JSON.decode user.followings_ids
+      followers_ids = ActiveSupport::JSON.decode user.followers_ids
+      user.following_count = followings_ids.size
+      user.follower_count = followers_ids.size
+      user.save
+      followings_ids.each do |followed_id|
+        ::Inkwell::Following.create :follower_id => user.id, :followed_id => followed_id
+      end
+    end
+
+    remove_column ::Inkwell::Engine::config.user_table, :followers_ids
+    remove_column ::Inkwell::Engine::config.user_table, :followings_ids
+  end
+end

data/db/migrate/20130212130898_refactor_user_community_relation.rb

@@ -0,0 +1,72 @@
+class RefactorUserCommunityRelation < ActiveRecord::Migration
+  def change
+    if ::Inkwell::Engine::config.respond_to?('community_table')
+      user_id = "#{::Inkwell::Engine::config.user_table.to_s.singularize}_id"
+      community_id = "#{::Inkwell::Engine::config.community_table.to_s.singularize}_id"
+
+      create_table :inkwell_community_users do |t|
+        t.integer user_id
+        t.integer community_id
+        t.string :user_access, :default => "r"
+        t.boolean :is_admin, :default => false
+        t.integer :admin_level
+        t.boolean :muted, :default => false
+
+        t.timestamps
+      end
+
+      add_column ::Inkwell::Engine::config.community_table, :user_count, :integer, :default => 0
+      add_column ::Inkwell::Engine::config.community_table, :writer_count, :integer, :default => 0
+      add_column ::Inkwell::Engine::config.community_table, :admin_count, :integer, :default => 0
+      add_column ::Inkwell::Engine::config.community_table, :muted_count, :integer, :default => 0
+      add_column ::Inkwell::Engine::config.user_table, :community_count, :integer, :default => 0
+
+      community_class = Object.const_get ::Inkwell::Engine::config.community_table.to_s.singularize.capitalize
+
+      community_class.all.each do |community|
+        users_ids = ActiveSupport::JSON.decode community.users_ids
+        community.user_count = users_ids.size
+
+        users_ids.each do |uid|
+          ::Inkwell::CommunityUser.create user_id => uid, community_id => community.id
+        end
+
+        writers_ids = ActiveSupport::JSON.decode community.writers_ids
+        community.writer_count = writers_ids.size
+
+        writers_ids.each do |uid|
+          ::Inkwell::CommunityUser.where(user_id => uid, community_id => community.id).update_all(:user_access => "w")
+        end
+
+        admins_info = ActiveSupport::JSON.decode community.admins_info
+        community.admin_count = admins_info.size
+
+        admins_info.each do |rec|
+          ::Inkwell::CommunityUser.where(user_id => rec['admin_id'], community_id => community.id).update_all(:is_admin => true, :admin_level => rec['admin_level'])
+        end
+
+        muted_ids = ActiveSupport::JSON.decode community.muted_ids
+        community.muted_count = muted_ids.size
+
+        muted_ids.each do |uid|
+          ::Inkwell::CommunityUser.where(user_id => uid, community_id => community.id).update_all(:muted => true)
+        end
+
+        community.save
+      end
+
+      user_class = Object.const_get ::Inkwell::Engine::config.user_table.to_s.singularize.capitalize
+      user_class.all.each do |user|
+        communities_info = ActiveSupport::JSON.decode user.communities_info
+        user.community_count = communities_info.size
+        user.save
+      end
+
+      remove_column ::Inkwell::Engine::config.community_table, :users_ids
+      remove_column ::Inkwell::Engine::config.community_table, :writers_ids
+      remove_column ::Inkwell::Engine::config.community_table, :admins_info
+      remove_column ::Inkwell::Engine::config.community_table, :muted_ids
+      remove_column ::Inkwell::Engine::config.user_table, :communities_info
+    end
+  end
+end

data/db/migrate/20130212130908_refactor_invites_bans_mutes.rb

@@ -0,0 +1,48 @@
+class RefactorInvitesBansMutes < ActiveRecord::Migration
+  def change
+    if ::Inkwell::Engine::config.respond_to?('community_table')
+      user_id = "#{::Inkwell::Engine::config.user_table.to_s.singularize}_id"
+      community_id = "#{::Inkwell::Engine::config.community_table.to_s.singularize}_id"
+
+      add_column ::Inkwell::Engine::config.community_table, :banned_count, :integer, :default => 0
+      add_column ::Inkwell::Engine::config.community_table, :invitation_count, :integer, :default => 0
+
+      change_column ::Inkwell::Engine::config.community_table, :user_count, :integer, :default => 1
+      change_column ::Inkwell::Engine::config.community_table, :admin_count, :integer, :default => 1
+      change_column ::Inkwell::Engine::config.community_table, :writer_count, :integer, :default => 1
+
+      add_column :inkwell_community_users, :active, :boolean, :default => false
+      add_column :inkwell_community_users, :banned, :boolean, :default => false
+      add_column :inkwell_community_users, :asked_invitation, :boolean, :default => false
+
+      community_class = Object.const_get ::Inkwell::Engine::config.community_table.to_s.singularize.capitalize
+
+      community_class.all.each do |community|
+        banned_ids = ActiveSupport::JSON.decode community.banned_ids
+        community.banned_count = banned_ids.size
+        banned_ids.each do |uid|
+          relations = ::Inkwell::CommunityUser.where community_id => community.id, user_id => uid
+          if relations.empty?
+            ::Inkwell::CommunityUser.create community_id => community.id, user_id => uid, :active => false, :banned => true
+          else
+            relation = relations.first
+            relation.active = false
+            relation.banned = true
+            relation.save
+          end
+        end
+
+        invitations_uids = ActiveSupport::JSON.decode community.invitations_uids
+        community.invitation_count = invitations_uids.size
+        invitations_uids.each do |uid|
+          ::Inkwell::CommunityUser.create community_id => community.id, user_id => uid, :active => false, :asked_invitation => true
+        end
+
+        community.save
+      end
+
+      remove_column ::Inkwell::Engine::config.community_table, :banned_ids
+      remove_column ::Inkwell::Engine::config.community_table, :invitations_uids
+    end
+  end
+end

data/lib/acts_as_inkwell_community/base.rb

@@ -12,9 +12,18 @@ module Inkwell
       def acts_as_inkwell_community
         validates :owner_id, :presence => true
 
+        if ::Inkwell::Engine::config.respond_to?('community_table')
+          has_many :communities_users, :class_name => 'Inkwell::CommunityUser'
+          has_many :users, :through => :communities_users, :class_name => ::Inkwell::Engine::config.user_table.to_s.singularize.capitalize, :conditions => {"inkwell_community_users.active" => true}
+          has_many :admins, :through => :communities_users, :class_name => ::Inkwell::Engine::config.user_table.to_s.singularize.capitalize, :conditions => {"inkwell_community_users.is_admin" => true, "inkwell_community_users.active" => true}
+          has_many :writers, :through => :communities_users, :class_name => ::Inkwell::Engine::config.user_table.to_s.singularize.capitalize, :conditions => {"inkwell_community_users.user_access" => ::Inkwell::Constants::CommunityAccessLevels::WRITE, "inkwell_community_users.active" => true}
+          has_many :muted_users, :through => :communities_users, :class_name => ::Inkwell::Engine::config.user_table.to_s.singularize.capitalize, :conditions => {"inkwell_community_users.muted" => true, "inkwell_community_users.active" => true}
+          has_many :banned_users, :through => :communities_users, :class_name => ::Inkwell::Engine::config.user_table.to_s.singularize.capitalize, :conditions => {"inkwell_community_users.banned" => true}
+          has_many :asked_invitation_users, :through => :communities_users, :class_name => ::Inkwell::Engine::config.user_table.to_s.singularize.capitalize, :conditions => {"inkwell_community_users.asked_invitation" => true}
+        end
+
         after_create :processing_a_community
         before_destroy :destroy_community_processing
-
         include ::Inkwell::ActsAsInkwellCommunity::InstanceMethods
       end
     end
@@ -27,26 +36,29 @@ module Inkwell
       def add_user(options = {})
         options.symbolize_keys!
         user = options[:user]
-        raise "this user is already in this community" if self.include_user? user
-        raise "this user is banned" if self.include_banned_user? user
-
-        users_ids = ActiveSupport::JSON.decode self.users_ids
-        users_ids << user.id
-        self.users_ids = ActiveSupport::JSON.encode users_ids
-        if (self.default_user_access == CommunityAccessLevels::WRITE) && !(self.include_muted_user? user)
-          writers_ids = ActiveSupport::JSON.decode self.writers_ids
-          writers_ids << user.id
-          self.writers_ids = ActiveSupport::JSON.encode writers_ids
+        check_user user
+
+        relation = ::Inkwell::CommunityUser.where(user_id_attr => user.id, community_id_attr => self.id).first
+
+        if relation
+          raise "this user is already in this community" if relation.active
+          raise "this user is banned" if relation.banned
+
+          relation.asked_invitation = false if relation.asked_invitation
+          relation.user_access = self.default_user_access
+          relation.active = true
+          relation.save
+        else
+          relation = ::Inkwell::CommunityUser.create user_id_attr => user.id, community_id_attr => self.id, :user_access => self.default_user_access, :active => true
         end
-        self.save
 
-        communities_info = ActiveSupport::JSON.decode user.communities_info
-        communities_info << Hash[HashParams::COMMUNITY_ID => self.id, HashParams::ACCESS_LEVEL => self.default_user_access]
-        user.communities_info = ActiveSupport::JSON.encode communities_info
+
+        self.user_count += 1
+        self.writer_count += 1 if relation.user_access == CommunityAccessLevels::WRITE
+        self.save
+        user.community_count += 1
         user.save
 
-        post_class = Object.const_get ::Inkwell::Engine::config.post_table.to_s.singularize.capitalize
-        user_id_attr = "#{::Inkwell::Engine::config.user_table.to_s.singularize}_id"
         ::Inkwell::BlogItem.where(:owner_id => self.id, :owner_type => OwnerTypes::COMMUNITY).order("created_at DESC").limit(10).each do |blog_item|
           next if post_class.find(blog_item.item_id).send(user_id_attr) == user.id
 
@@ -76,25 +88,23 @@ module Inkwell
           raise "admin has no permissions to delete this user from community" if (self.admin_level_of(user) <= self.admin_level_of(admin)) && (user != admin)
         end
 
-        users_ids = ActiveSupport::JSON.decode self.users_ids
-        users_ids.delete user.id
-        self.users_ids = ActiveSupport::JSON.encode users_ids
-
-        writers_ids = ActiveSupport::JSON.decode self.writers_ids
-        writers_ids.delete user.id
-        self.writers_ids = ActiveSupport::JSON.encode writers_ids
-
-        admins_info = ActiveSupport::JSON.decode self.admins_info
-        admins_info.delete_if{|item| item['admin_id'] == user.id}
-        self.admins_info = ActiveSupport::JSON.encode admins_info
+        relation = ::Inkwell::CommunityUser.where(user_id_attr => user.id, community_id_attr => self.id).first
 
+        self.user_count -= 1
+        self.writer_count -= 1 if relation.user_access == CommunityAccessLevels::WRITE
+        self.admin_count -= 1 if relation.is_admin
+        self.muted_count -= 1 if relation.muted
         self.save
-
-        communities_info = ActiveSupport::JSON.decode user.communities_info
-        communities_info.delete_if {|item| item[HashParams::COMMUNITY_ID] == self.id}
-        user.communities_info = ActiveSupport::JSON.encode communities_info
+        user.community_count -= 1
         user.save
 
+        if relation.muted
+          relation.active = false
+          relation.save
+        else
+          relation.destroy
+        end
+
         timeline_items = ::Inkwell::TimelineItem.where(:owner_id => user.id, :owner_type => OwnerTypes::USER).where "from_source like '%{\"community_id\":#{self.id}%'"
         timeline_items.delete_all :has_many_sources => false
         timeline_items.each do |item|
@@ -108,14 +118,12 @@ module Inkwell
 
       def include_writer?(user)
         check_user user
-        writers_ids = ActiveSupport::JSON.decode self.writers_ids
-        writers_ids.include? user.id
+        ::Inkwell::CommunityUser.exists? user_id_attr => user.id, community_id_attr => self.id, :user_access => CommunityAccessLevels::WRITE, :active => true
       end
 
       def include_user?(user)
         check_user user
-        communities_info = ActiveSupport::JSON.decode user.communities_info
-        (communities_info.index{|item| item[HashParams::COMMUNITY_ID] == self.id}) ? true : false
+        ::Inkwell::CommunityUser.exists? user_id_attr => user.id, community_id_attr => self.id, :active => true
       end
 
       def mute_user(options = {})
@@ -126,16 +134,19 @@ module Inkwell
         raise "admin should be passed in params" unless admin
         check_user user
         check_user admin
+
+        relation = ::Inkwell::CommunityUser.where(user_id_attr => user.id, community_id_attr => self.id).first
+
         raise "admin is not admin" unless self.include_admin? admin
-        raise "user should be a member of this community" unless self.include_user? user
-        raise "this user is already muted" if self.include_muted_user? user
+        raise "user should be a member of this community" unless relation
+        raise "this user is already muted" if relation.muted
         raise "it is impossible to mute yourself" if user == admin
-        raise "admin has no permissions to mute this user" if (self.include_admin? user) && (admin_level_of(admin) >= admin_level_of(user))
+        raise "admin has no permissions to mute this user" if (relation.is_admin) && (admin_level_of(admin) >= relation.admin_level)
 
+        relation.muted = true
+        relation.save
 
-        muted_ids = ActiveSupport::JSON.decode self.muted_ids
-        muted_ids << user.id
-        self.muted_ids = ActiveSupport::JSON.encode muted_ids
+        self.muted_count += 1
         self.save
       end
 
@@ -147,21 +158,24 @@ module Inkwell
         raise "admin should be passed in params" unless admin
         check_user user
         check_user admin
+
+        relation = ::Inkwell::CommunityUser.where(user_id_attr => user.id, community_id_attr => self.id).first
+
         raise "admin is not admin" unless self.include_admin? admin
-        raise "user should be a member of this community" unless self.include_user? user
-        raise "this user is not muted" unless self.include_muted_user? user
-        raise "admin has no permissions to unmute this user" if (self.include_admin? user) && (admin_level_of(admin) >= admin_level_of(user))
+        raise "user should be a member of this community" unless relation
+        raise "this user is not muted" unless relation.muted
+        raise "admin has no permissions to unmute this user" if (relation.is_admin) && (admin_level_of(admin) >= relation.admin_level)
+
+        relation.muted = false
+        relation.save
 
-        muted_ids = ActiveSupport::JSON.decode self.muted_ids
-        muted_ids.delete user.id
-        self.muted_ids = ActiveSupport::JSON.encode muted_ids
+        self.muted_count -= 1
         self.save
       end
 
       def include_muted_user?(user)
         check_user user
-        muted_ids = ActiveSupport::JSON.decode self.muted_ids
-        muted_ids.include? user.id
+        ::Inkwell::CommunityUser.exists? user_id_attr => user.id, community_id_attr => self.id, :muted => true, :active => true
       end
 
       def ban_user(options = {})
@@ -173,22 +187,23 @@ module Inkwell
         check_user user
         check_user admin
         raise "admin is not admin" unless self.include_admin? admin
-        if self.public
-          raise "user should be a member of public community" unless self.include_user?(user)
+        raise "admin has no permissions to ban this user" if (self.include_admin? user) && (admin_level_of(admin) >= admin_level_of(user))
+
+        relation = ::Inkwell::CommunityUser.where(user_id_attr => user.id, community_id_attr => self.id).first
+        raise "user should be a member of community or send invitation request to it" unless relation
+        raise "this user is already banned" if relation.banned
+        relation.banned = true
+        relation.active = false
+        if relation.asked_invitation
+          relation.asked_invitation = false
+          self.invitation_count -= 1
         else
-          raise "user should be a member of private community or send invitation request to it" unless self.include_user?(user) || self.include_invitation_request?(user)
+          self.user_count -= 1
         end
-        raise "this user is already banned" if self.include_banned_user? user
-        raise "admin has no permissions to ban this user" if (self.include_admin? user) && (admin_level_of(admin) >= admin_level_of(user))
+        relation.save
 
-        banned_ids = ActiveSupport::JSON.decode self.banned_ids
-        banned_ids << user.id
-        self.banned_ids = ActiveSupport::JSON.encode banned_ids
+        self.banned_count += 1
         self.save
-        unless self.public
-          self.reject_invitation_request :admin => admin, :user => user if self.include_invitation_request? user
-        end
-        self.remove_user :admin => admin, :user => user
       end
 
       def unban_user(options = {})
@@ -200,18 +215,20 @@ module Inkwell
         check_user user
         check_user admin
         raise "admin is not admin" unless self.include_admin? admin
-        raise "this user is not banned" unless self.include_banned_user? user
 
-        banned_ids = ActiveSupport::JSON.decode self.banned_ids
-        banned_ids.delete user.id
-        self.banned_ids = ActiveSupport::JSON.encode banned_ids
+        relation = ::Inkwell::CommunityUser.where(user_id_attr => user.id, community_id_attr => self.id).first
+        raise "this user is not banned" unless relation || relation.banned
+
+        relation.banned = false
+        relation.active = true unless relation.asked_invitation
+        relation.save
+
+        self.banned_count -= 1
         self.save
       end
 
       def include_banned_user?(user)
-        check_user user
-        banned_ids = ActiveSupport::JSON.decode self.banned_ids
-        banned_ids.include? user.id
+        ::Inkwell::CommunityUser.exists? :community_id => self.id, :user_id => user.id, :banned => true
       end
 
       def add_admin(options = {})
@@ -222,23 +239,27 @@ module Inkwell
         raise "admin should be passed in params" unless admin
         check_user user
         check_user admin
-        raise "user is already admin" if self.include_admin? user
-        raise "admin is not admin" unless self.include_admin? admin
-        raise "user should be a member of this community" unless self.include_user? user
 
-        self.unmute_user :user => user, :admin => admin if self.include_muted_user? user
+        relation = ::Inkwell::CommunityUser.where(user_id_attr => user.id, community_id_attr => self.id).first
 
-        unless self.include_writer? user
-          writers_ids = ActiveSupport::JSON.decode self.writers_ids
-          writers_ids << user.id
-          self.writers_ids = ActiveSupport::JSON.encode writers_ids
-        end
+        raise "user should be in the community" unless relation
+        raise "user is already admin" if relation.is_admin
+        raise "admin is not admin" unless self.include_admin? admin
+        raise "user should be a member of this community" unless relation
 
-        admin_level_granted_for_user = admin_level_of(admin) + 1
+        if relation.muted
+          relation.muted = false
+          self.muted_count -= 1
+        end
+        unless relation.user_access == CommunityAccessLevels::WRITE
+          relation.user_access = CommunityAccessLevels::WRITE
+          self.writer_count += 1
+        end
+        relation.admin_level = admin_level_of(admin) + 1
+        relation.is_admin = true
+        relation.save
 
-        admins_info = ActiveSupport::JSON.decode self.admins_info
-        admins_info << Hash['admin_id' => user.id, 'admin_level' => admin_level_granted_for_user]
-        self.admins_info = ActiveSupport::JSON.encode admins_info
+        self.admin_count += 1
         self.save
       end
 
@@ -253,24 +274,22 @@ module Inkwell
         raise "admin has no permissions to delete this user from admins" if (admin_level_of(admin) >= admin_level_of(user)) && (user != admin)
         raise "community owner can not be removed from admins" if admin_level_of(user) == 0
 
-        admins_info = ActiveSupport::JSON.decode self.admins_info
-        admins_info.delete_if{|rec| rec['admin_id'] == user.id}
-        self.admins_info = ActiveSupport::JSON.encode admins_info
+        ::Inkwell::CommunityUser.where(user_id_attr => user.id, community_id_attr => self.id).update_all :is_admin => false, :admin_level => nil
+
+        self.admin_count -= 1
         self.save
       end
 
       def admin_level_of(admin)
-        admin_positions = ActiveSupport::JSON.decode self.admins_info
-        index = admin_positions.index{|item| item['admin_id'] == admin.id}
-        raise "admin is not admin" unless index
-        admin_positions[index]['admin_level']
+        relation = ::Inkwell::CommunityUser.where(user_id_attr => admin.id, community_id_attr => self.id).first
+        raise "this user is not community member" unless relation
+        raise "admin is not admin" unless relation.is_admin
+        relation.admin_level
       end
 
       def include_admin?(user)
         check_user user
-
-        admin_positions = ActiveSupport::JSON.decode self.admins_info
-        (admin_positions.index{|item| item['admin_id'] == user.id}) ? true : false
+        ::Inkwell::CommunityUser.exists? user_id_attr => user.id, community_id_attr => self.id, :is_admin => true, :active => true
       end
 
       def add_post(options = {})
@@ -302,9 +321,9 @@ module Inkwell
           item.save
         end
 
-        self.users_row.each do |user_id|
-          next if users_with_existing_items.include? user_id
-          ::Inkwell::TimelineItem.create :item_id => post.id, :owner_id => user_id, :owner_type => OwnerTypes::USER, :item_type => ItemTypes::POST,
+        self.users_row.each do |uid|
+          next if users_with_existing_items.include? uid
+          ::Inkwell::TimelineItem.create :item_id => post.id, :owner_id => uid, :owner_type => OwnerTypes::USER, :item_type => ItemTypes::POST,
                                          :from_source => ActiveSupport::JSON.encode([Hash['community_id' => self.id]])
         end
       end
@@ -380,30 +399,47 @@ module Inkwell
       end
 
       def users_row
-        ActiveSupport::JSON.decode self.users_ids
+        relations = ::Inkwell::CommunityUser.where community_id_attr => self.id
+        result = []
+        relations.each do |rel|
+          result << rel.send(user_id_attr)
+        end
+        result
       end
 
       def writers_row
-        ActiveSupport::JSON.decode self.writers_ids
+        relations = ::Inkwell::CommunityUser.where community_id_attr => self.id, :user_access => CommunityAccessLevels::WRITE
+        result = []
+        relations.each do |rel|
+          result << rel.send(user_id_attr)
+        end
+        result
       end
 
       def admins_row
-        admins_info = ActiveSupport::JSON.decode self.admins_info
+        relations = ::Inkwell::CommunityUser.where community_id_attr => self.id, :is_admin => true
         result = []
-        admins_info.each do |rec|
-          result << rec['admin_id']
+        relations.each do |rel|
+          result << rel.send(user_id_attr)
         end
         result
       end
 
       def create_invitation_request(user)
-        raise "invitation request was already created" if self.include_invitation_request? user
-        raise "it is impossible to create request. user is banned in this community" if self.include_banned_user? user
+        check_user user
+
+        relation = ::Inkwell::CommunityUser.where(community_id_attr => self.id, user_id_attr => user.id).first
+        if relation
+          raise "invitation request was already created" if relation.asked_invitation
+          raise "it is impossible to create request. user is banned in this community" if relation.banned
+          raise "user is already community member" if relation.active
+          raise "there is relation for user who is not member of community and he is not banned and not asked invitation to it"
+        end
         raise "it is impossible to create request for public community" if self.public
 
-        invitations_uids = ActiveSupport::JSON.decode self.invitations_uids
-        invitations_uids << user.id
-        self.invitations_uids = ActiveSupport::JSON.encode invitations_uids
+        ::Inkwell::CommunityUser.create community_id_attr => self.id, user_id_attr => user.id, :asked_invitation => true, :active => false
+
+        self.invitation_count += 1
         self.save
       end
 
@@ -414,12 +450,15 @@ module Inkwell
         check_user user
         check_user admin
         raise "admin is not admin in this community" unless self.include_admin? admin
-        raise "this user is already in this community" if self.include_user? user
-        raise "there is no invitation request for this user" unless self.include_invitation_request? user
+
+        relation = ::Inkwell::CommunityUser.where(community_id_attr => self.id, user_id_attr => user.id).first
+        raise "this user is already in this community" if relation.active
+        raise "there is no invitation request for this user" unless relation.asked_invitation
 
         self.add_user :user => user
 
-        remove_invitation_request user
+        self.invitation_count -= 1
+        self.save
       end
 
       def reject_invitation_request(options = {})
@@ -428,16 +467,29 @@ module Inkwell
         admin = options[:admin]
         check_user user
         check_user admin
-        raise "there is no invitation request for this user" unless self.include_invitation_request? user
+
+        relation = ::Inkwell::CommunityUser.where(community_id_attr => self.id, user_id_attr => user.id).first
+        raise "there is no invitation request for this user" unless relation || relation.asked_invitation
         raise "admin is not admin in this community" unless self.include_admin? admin
 
-        remove_invitation_request user
+        relation.destroy
+
+        self.invitation_count -= 1
+        self.save
       end
 
       def include_invitation_request?(user)
         raise "invitations work only for private community. this community is public." if self.public
-        invitations_uids = ActiveSupport::JSON.decode self.invitations_uids
-        (invitations_uids.index{|uid| uid == user.id}) ? true : false
+        ::Inkwell::CommunityUser.exists? community_id_attr => self.id, user_id_attr => user.id, :asked_invitation => true
+      end
+
+      def invitations_row
+        relations = ::Inkwell::CommunityUser.where community_id_attr => self.id, :asked_invitation => true
+        result = []
+        relations.each do |relation|
+          result << relation.send(user_id_attr)
+        end
+        result
       end
 
       def change_default_access_to_write
@@ -456,98 +508,51 @@ module Inkwell
 
       def set_write_access(uids)
         raise "array with users ids should be passed" unless uids.class == Array
-        users_ids = self.users_row
-        matching_ids = users_ids & uids
-        unless matching_ids.size == uids.size
-          mismatched_ids = uids - matching_ids
-          raise "there is no users with ids #{mismatched_ids} in the community"
-        end
-
-        current_writers_ids = ActiveSupport::JSON.decode self.writers_ids
-        already_added_ids = current_writers_ids & uids
-        uids -= already_added_ids
+        relations = ::Inkwell::CommunityUser.where user_id_attr => uids, community_id_attr => self.id, :user_access => CommunityAccessLevels::READ, :is_admin => false
+        raise "there is different count of passed uids (#{uids.size}) and found users (#{relations.size}) in this community" unless relations.size == uids.size
 
-        current_writers_ids += uids
-        self.writers_ids = ActiveSupport::JSON.encode current_writers_ids
+        self.writer_count += relations.size
         self.save
 
-        user_class = Object.const_get ::Inkwell::Engine::config.user_table.to_s.singularize.capitalize
-        users = user_class.find uids
-        users.each do |user|
-          raise "user with id #{uid} does not exist" unless user
-          communities_info = ActiveSupport::JSON.decode user.communities_info
-          index = communities_info.index { |rec| rec[HashParams::COMMUNITY_ID] == self.id }
-          communities_info[index][HashParams::ACCESS_LEVEL] = CommunityAccessLevels::WRITE
-          user.communities_info = ActiveSupport::JSON.encode communities_info
-          user.save
-        end
+        relations.update_all :user_access => CommunityAccessLevels::WRITE
       end
 
       def set_read_access(uids)
         raise "array with users ids should be passed" unless uids.class == Array
-        users_ids = self.users_row
-        matching_ids = users_ids & uids
-        unless matching_ids.size == uids.size
-          mismatched_ids = uids - matching_ids
-          raise "there is no users with ids #{mismatched_ids} in the community"
-        end
+        relations = ::Inkwell::CommunityUser.where user_id_attr => uids, community_id_attr => self.id, :user_access => CommunityAccessLevels::WRITE, :is_admin => false
+        raise "there is different count of passed uids (#{uids.size}) and found users (#{relations.size}) in this community" unless relations.size == uids.size
 
-        matching_ids = self.admins_row & uids
-        raise "there is impossible to change access level to read for admins with ids #{matching_ids} in the community" unless matching_ids.empty?
-
-        current_writers_ids = ActiveSupport::JSON.decode self.writers_ids
-        current_writers_ids -= uids
-        self.writers_ids = ActiveSupport::JSON.encode current_writers_ids
+        self.writer_count -= relations.size
         self.save
 
-        user_class = Object.const_get ::Inkwell::Engine::config.user_table.to_s.singularize.capitalize
-        users = user_class.find uids
-        users.each do |user|
-          raise "user with id #{uid} does not exist" unless user
-          communities_info = ActiveSupport::JSON.decode user.communities_info
-          index = communities_info.index { |rec| rec[HashParams::COMMUNITY_ID] == self.id }
-          communities_info[index][HashParams::ACCESS_LEVEL] = CommunityAccessLevels::READ
-          user.communities_info = ActiveSupport::JSON.encode communities_info
-          user.save
-        end
+        relations.update_all :user_access => CommunityAccessLevels::READ
       end
 
-      private
-
-      def remove_invitation_request(user)
-        invitations_uids = ActiveSupport::JSON.decode self.invitations_uids
-        invitations_uids.delete user.id
-        self.invitations_uids = ActiveSupport::JSON.encode invitations_uids
-        self.save
+      def reader_count
+        self.user_count - self.writer_count
       end
 
+      private
+
       def processing_a_community
-        user_class = Object.const_get ::Inkwell::Engine::config.user_table.to_s.singularize.capitalize
         owner = user_class.find self.owner_id
-
-        communities_info = ActiveSupport::JSON.decode owner.communities_info
-        communities_info << Hash[HashParams::COMMUNITY_ID => self.id, HashParams::ACCESS_LEVEL => self.default_user_access]
-        owner.communities_info = ActiveSupport::JSON.encode communities_info
+        owner.community_count += 1
         owner.save
 
-        admins_info = [Hash['admin_id' => owner.id, 'admin_level' => 0]]
-        self.admins_info = ActiveSupport::JSON.encode admins_info
-        self.users_ids = ActiveSupport::JSON.encode [owner.id]
-        self.writers_ids = ActiveSupport::JSON.encode [owner.id]
-        self.save
+        ::Inkwell::CommunityUser.create user_id_attr => self.owner_id, community_id_attr => self.id, :is_admin => true, :admin_level => 0,
+                                        :user_access => CommunityAccessLevels::WRITE, :active => true
       end
 
       def destroy_community_processing
-        user_class = Object.const_get ::Inkwell::Engine::config.user_table.to_s.singularize.capitalize
-        users_ids = ActiveSupport::JSON.decode self.users_ids
-        users_ids.each do |user_id|
-          user = user_class.find user_id
-          communities_info = ActiveSupport::JSON.decode user.communities_info
-          communities_info.delete_if {|item| item[HashParams::COMMUNITY_ID] == self.id}
-          user.communities_info = ActiveSupport::JSON.encode communities_info
+        users_ids = self.users_row
+        users_ids.each do |uid|
+          user = user_class.find uid
+          user.community_count -= 1
           user.save
         end
 
+        ::Inkwell::CommunityUser.delete_all community_id_attr => self.id
+
         timeline_items = ::Inkwell::TimelineItem.where "from_source like '%{\"community_id\":#{self.id}%'"
         timeline_items.delete_all :has_many_sources => false
         timeline_items.each do |item|