cloudwow-not_relational 0.1.0

data/test/models/group.rb

@@ -0,0 +1,283 @@
+require 'digest/sha1'
+require "uri"
+require "not_relational/domain_model.rb"
+require "models/tag.rb"
+
+class Group < NotRelational::DomainModel
+    encrypt_me
+  property :id,:string,:is_primary_key=>true
+  property :name , :string,:unique=>true
+  property :normalized_name , :string,:unique=>true
+  property :creator , :string
+  property :creation_date , :date
+  property :description , :string
+  property :is_public , :boolean
+  property :short_description , :string
+  property :icon_guid , :string
+  property :tags , :string
+  property :layout , :clob
+  property :domain , :string,:unique=>true
+  
+  property :devpay_user_token , :string
+  property :devpay_bucket , :string
+  
+  
+  has_many :GroupInvite
+  has_many :GroupMember,:group_id ,:group_members,:order_by => :member_login
+  has_many :GroupChannel
+  has_many :Album,:group_id,:albums,:order=>:descending,:order_by=>:created_time_utc
+  has_many :MediaItem,:group_id,:media_items,:order=>:descending,:order_by=>:created_time
+  many_to_many :Node,:GroupChannel,:group_id,:node_id,:channels
+   
+    
+  
+    
+  def Group.create_group(name,short_description,description,tags,is_public,creator_login)
+
+    group=Group.find_by_normalized_name(name)
+    if !group
+      group=Group.new
+      group.name=name
+      group.description=description
+      group.short_description=short_description
+      group.is_public=is_public
+      group.creator=creator_login
+      group.creation_date=Time.now.gmtime
+      group.tags=tags
+      group.save!
+          
+      channel_node=Node.fill_new_node(creator_login,name+" Discussion","")
+      channel_node.isChannel=true
+      channel_node.publicRead=false
+      channel_node.publicWrite=false
+      channel_node.save!
+
+      group_channel=GroupChannel.new
+      group_channel.node_id=channel_node.id
+      group_channel.group_id=group.id
+      group_channel.save
+
+      group.add_member(creator_login)
+    end
+    return group
+  end
+  def add_member(login)
+    member=GroupMember.find_by_group_and_login(self.id,login)
+    if ! member
+      member=GroupMember.new
+      member.group_id=self.id
+      member.member_login=login
+      member.save!
+      @accessor_cache.delete(:group_members)
+    end
+    
+    return member
+  end
+  def members
+    result=[]
+    for member in self.group_members
+      member_user=User.find(member.member_login)
+      result<<member_user if member_user
+    end
+    return result;
+  end
+  def Group.url_from_name(name)
+    "/groups/"+URI.escape(name.capitalize, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))
+  end
+  def Group.create_thread_form_url_from_name(name)
+    Group.url_from_name(name)+"/forum/create_thread_form"
+  end
+  def Group.create_thread_url_from_name(name)
+    Group.url_from_name(name)+"/forum/create_thread"
+  end
+  def Group.show_thread_url_from_name(name,thread_id)
+    return Group.url_from_name(name)+"/thread/#{thread_id}"
+  end
+   def Group.domained_groups
+      Group.find(:all,:params=>{:domain=>:NOT_NULL})
+    end
+  def url
+    Group.url_from_name(self.name)
+  end
+  def tag_url(tag_name)
+    self.url+"/tag/"+URI.escape(tag_name.downcase, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))
+  end
+  def members_url
+    self.url
+  end
+  def Group.forum_url_from_name(name)
+    Group.url_from_name(name)+"/forum"
+  end
+  def forum_url
+    Group.forum_url_from_name(self.name)
+  end
+  def invite_url
+    self.url+"/invite"
+  end
+  def create_album_url
+    Group.create_album_url_from_name(self.name.downcase)
+  end
+  def Group.create_album_url_from_name(name)
+    Group.url_from_name(name)+"/create_album"
+  end
+     
+  def create_event_url
+    self.url+"/create_event"
+  end
+  def create_thread_url
+    Group.create_thread_url_from_name(self.name.downcase)
+  end
+  def show_thread_url(thread_id)
+    return Group.show_thread_url_from_name(self.name,thread_id)
+  end
+     
+  def create_thread_form_url
+    Group.create_thread_form_url_from_name(self.name.downcase)
+  end
+  def join_url
+         
+    self.url+"/join_public"
+  end
+  def join_with_invitation_url(token,language=nil)
+    domain=self.domain || "globalcoordinate.com"
+    if language 
+      domain=language+"."+domain
+    end
+    return "http://"+domain+self.url+"/join/"+token
+  end
+  def news_feed_url
+    self.url+"/news_stream"
+  end
+  def members_url
+    self.url+"/members"
+  end
+  def albums_url
+    self.url+"/albums"
+  end
+  def create_invite(email_address)
+       
+    invite=GroupInvite.new
+    invite.token="#{NotRelational::UUID.generate.to_s}"
+    invite.group_id=self.id
+    invite.email_address=email_address
+    invite.save!
+    return invite
+  end
+  def tag_cloud
+    tag_cloud=TagCloud.new(Tag.find_group_media_tags(self.id ))
+   
+  end
+  def channel
+    temp=channels
+    return nil if temp.length==0
+    return temp[0]
+  end
+  def is_my_thread(thread_node)
+    return thread_node.parent_id==channel.id
+        
+        
+  end
+  def icon
+    if self.icon_guid
+      return Mediaitem.find(:first,:params=>{:guid=>self.icon_guid})
+    end
+  end
+  @cached_events=nil
+  def recent_events(how_many=32)
+    
+    UserEvent.find(:all,:limit=>how_many,:order=>:descending,:order_by=>:event_time,:params=>{:group_id=>self.id})
+    
+        
+  end
+  def Group.find_by_normalized_name(value)
+    find(:first,:params=>{:normalized_name=>value.capitalize})
+    
+  end
+  def Group.find_by_name(value)
+    Group.find_by_normalized_name(value)
+    
+  end
+  def name=(value)
+    self.normalized_name=value
+    super(value)
+  end
+  def normalized_name=(value)
+    value=value.capitalize
+    super(value)
+  end
+  def Group.convert_arg_to_group(group_arg)
+    return nil unless group_arg
+    group=nil
+    if group_arg.respond_to?(:name)
+      group=group_arg
+    else
+      group=Group.find_by_normalized_name(group_arg)
+    end
+    return group
+  end
+  def is_member?(login)
+    member=GroupMember.find_by_group_and_login(self.id,login)
+    return member!=nil
+            
+  end
+  def create_thread(author,title,content)
+    channel=self.channels[0]
+      
+    new_node=Node.fill_new_node(author,title,content)
+    new_node.parent_id=channel.id
+    new_node.publicRead=false
+      
+    new_node.group_id=self.id
+    # new_node.is_private=true
+    new_node.save!
+    new_node
+  end
+  def post_to_thread(  author_login,thread_id,content)
+       
+    
+    channel=self.channels[0]
+    thread=Node.find(thread_id)
+    author=User.find(author_login)
+    return if thread.parent_id!=channel.id
+    new_node=Node.fill_new_node(author.login,"re: "+thread.latestTitle,content)
+    new_node.parent_id=thread.id
+    new_node.is_sterile=true;
+    new_node.isNews=false
+    new_node.publicRead=false
+    new_node.group_id=self.id
+    new_node.save! 
+      
+    thread.last_branch_update_time=new_node.last_branch_update_time
+    thread.save!
+    channel.last_branch_update_time=new_node.last_branch_update_time
+    channel.save!
+  end
+end
+class GroupChannel < NotRelational::DomainModel
+  property :id,:string,:is_primary_key=>true
+  property :group_id,:string
+  property :node_id,:string
+  belongs_to :Group
+  belongs_to :Node
+end
+class GroupMember < NotRelational::DomainModel
+  property :id,:string,:is_primary_key=>true
+  property :group_id,:string
+  property :member_login,:string
+  belongs_to :Group
+  belongs_to :User,:member_login,:member
+  index :group_and_login,[:group_id,:member_login],:unique=>true
+end
+class GroupInvite < NotRelational::DomainModel
+  property :id,:string,:is_primary_key=>true
+  property :group_id,:string
+  property :expiration_time,:date
+  property :redeemed_by_login,:string
+  property :redeemed_time,:date
+  property :outgoing_email_id,:string
+  property :token,:string,:unique=>true
+  property :email_address,:string
+  
+  belongs_to :Group
+  belongs_to :OutgoingEmail,:outgoing_email_id
+end

data/test/models/language.rb

@@ -0,0 +1,16 @@
+require 'digest/sha1'
+require "uri"
+
+require "model/domain_model.rb"
+
+
+class Language < DomainModel
+  property :id,:string,:is_primary_key=>true
+ property :name,:string
+ property :enabled ,:boolean  
+ 
+    def Language.enabled_languages
+     Language.find(:all,:order_by => 'name',:params=>{:enabled=>true}) 
+     
+    end
+end

data/test/models/media_file.rb

@@ -0,0 +1,32 @@
+require 'digest/sha1'
+require "uri"
+
+require "not_relational/domain_model.rb"
+class Mediafile < NotRelational::DomainModel
+    
+     property :id,:string,:is_primary_key=>true
+     property :mediaitem_id,:string
+     property :mimeType,:string
+     
+     property :width,:unsigned_integer
+     property :height,:unsigned_integer
+     property :fileSize,:unsigned_integer
+     property :bucket,:string
+     property :guid,:string,:unique=>true
+     
+     belongs_to :Mediaitem
+     
+  
+  
+  
+     def url
+      return "http://s3.amazonaws.com/#{self.bucket}/media/#{self.guid}"
+    end
+     def view_url
+       
+      return "/media/#{self.mediaitem.guid}/#{width}x#{height}/show.html"
+    end
+   
+    
+   
+end

data/test/models/media_item.rb

@@ -0,0 +1,258 @@
+require 'digest/sha1'
+require "uri"
+
+require "models/tag.rb"
+require "models/comment.rb"
+require "models/rating.rb"
+require "models/album.rb"
+require "models/media_file.rb"
+
+class Mediaitem < NotRelational::DomainModel
+  extend NotRelational::Geo::Locatable
+  include NotRelational::Geo::Locatable
+  property :id,:string,:is_primary_key=>true
+  property :guid,:string,:unique=>true
+  property :group_id , :string
+  property :title , :string
+  property :user_login , :string
+  property :description , :clob  
+  property :latitude        ,         :float                                                                                                                 
+  property :longitude       ,         :float                                                                                                                 
+                                                                                                        
+  property :address , :string
+  property :bucket , :string
+  property :length_in_seconds , :unsigned_integer
+  property :HasVideo , :boolean
+  property :HasAudio , :boolean
+  property :HasImage , :boolean
+  property :is_private , :boolean
+  property :created_time ,:date  
+    
+  has_many :Mediafile,nil,nil,:dependent=>:destroy
+  has_many :Tag,nil,nil,:dependent=>:destroy
+  has_many :Comment,nil,nil,:dependent=>:destroy
+  has_many :Rating,nil,nil,:dependent=>:destroy
+  has_many :AlbumMediaItem,nil,nil,:dependent=>:destroy
+  
+  index :hasimage_and_is_private,[:HasImage,:is_private]
+  index :hasvideo_and_is_private,[:HasVideo,:is_private]
+  index :hasaudio_and_is_private,[:HasAudio,:is_private]
+  index :hasaudio_hasvideo_and_is_private,[:HasAudio,:HasVideo,:is_private]
+  
+  many_to_many :Album,:AlbumMediaItem,:mediaitem_id,:album_id,:albums
+  belongs_to :Group
+  def Mediaitem.recent(how_many=24)
+    Mediaitem.find(:all,:order_by => :created_time,:order => :descending,:limit => how_many)
+      
+   
+  end
+  def Mediaitem.recent_video(how_many=24)
+            
+    Mediaitem.find_by_hasvideo_and_is_private(
+      true,
+      false ,
+      :order_by => :created_time,
+      :order => :descending,
+      :limit => how_many)
+   
+  end
+  def Mediaitem.recent_audio(how_many=24)
+    Mediaitem.find_by_hasaudio_and_is_private(
+      true,
+      false ,
+      :order_by => :created_time,
+      :order => :descending,
+      :limit => how_many)
+   
+  end
+  #hasimage is unreliable in the db
+  def HasImage
+    return false if self.HasVideo
+    return false if self.HasAudio
+    return true
+  end
+  def Mediaitem.recent_images(how_many=24)
+    #images are those that aren't video or audio
+    #hasimage flag is not rustworthy
+    Mediaitem.find_by_hasaudio_hasvideo_and_is_private(false,false,false ,:order_by => :created_time,:order => :descending,:limit => how_many)
+  end
+  def create_group_url(group_name)
+    return "#{Group.url_from_name(group_name)}/media/#{guid}"
+  end
+  def relative_url_from_root
+    return "media/"+self.guid+"/show.html"
+  end
+  def url
+    return "/media/"+self.guid+"/show.html"
+  end
+  def post_comment_url
+    return "/procyon/post_media_comment_form?mediaitem_id=#{id.to_s}&mediaitem_guid=#{guid}&return_url=#{CGI.escape relative_url_from_root}&mediaitem_thumb_w=#{thumbfile.width}&mediaitem_thumb_h=#{thumbfile.height}&mediaitem_thumb_url=#{thumbfile.url}"
+  end
+  def thumbfile
+    for mediafile in self.mediafiles 
+      if mediafile.width<=120 and mediafile.height<=120 and (mediafile.width==120 or mediafile.height==120) and mediafile.mimeType.index('image/')==0
+        return mediafile
+      end
+    end
+    return tiny_thumbfile
+  end
+  def tiny_thumbfile
+    for mediafile in self.mediafiles 
+      #not square
+      if mediafile.width<=60  and mediafile.height<=60  and (mediafile.height==60 || mediafile.width==60) and mediafile.mimeType.index('image/')==0
+        return mediafile
+      end
+    end
+    return nil
+  end
+  def square_thumbfile
+    for mediafile in self.mediafiles 
+      if mediafile.width==100  and mediafile.height==100  and mediafile.mimeType.index('image/')==0
+        return mediafile
+      end
+    end
+    return tiny_thumbfile
+  end
+  def tiny_square_thumbfile
+    for mediafile in self.mediafiles 
+      if mediafile.width==50  and mediafile.height==50  and mediafile.mimeType.index('image/')==0
+        return mediafile
+      end
+    end
+    return tiny_thumbfile
+  end
+  def big_thumbfile
+    for mediafile in self.mediafiles 
+      if mediafile.width>120 and mediafile.width<=240 and mediafile.height>120 and mediafile.height<=240 and mediafile.mimeType.index('image/')==0
+        return mediafile
+      end
+    end
+    return thumbfile
+  end
+  def file640
+    biggest=nil
+    for mediafile in self.mediafiles 
+      if mediafile.width<=640 and  mediafile.height<=640 and mediafile.width>1
+        if !biggest || mediafile.width>biggest.width
+          biggest=mediafile
+        end
+      end
+    end
+    if !biggest
+      return big_thumbfile
+    end
+    return biggest
+  end
+  def fileMaxSize
+    result=nil
+    for mediafile in self.mediafiles 
+      if result==nil || mediafile.width>result.width 
+        result=mediafile
+      end
+    end
+     
+    return result
+  end
+  def large_files
+    result=[]
+    for mediafile in self.mediafiles 
+      if mediafile.width>240 or  mediafile.height>240 
+        result<<mediafile
+      end
+    end
+    if result.length==0
+      result<<big_thumbfile
+    end
+    return result
+  end
+  def get_file_by_size_string(size)
+    the_mediafile=nil
+    for mediafile in self.mediafiles
+      if "#{mediafile.width}x#{mediafile.height}"==size
+        the_mediafile=mediafile
+      end
+    end
+    return the_mediafile
+  end
+  def get_tag_cloud
+    tag_data=self.tags
+    histogram=tag_data.inject(Hash.new(0)){|hash,x| hash[x.tag_name]+=1;hash}
+    tag_data=histogram.keys       
+    tag_data=tag_data.sort_by{|x|-histogram[x]}
+  end
+      
+  def kill
+    #      for media_file in mediafiles
+    #        media_file.destroy
+    #      end
+    #      for album_item in albummediaitems
+    #        album_item.destroy
+    #      end
+    self.destroy
+  end
+  def add_rating(rating)
+    rating.media_item.id=self.id
+    rating.save
+  end
+
+  # Helper method that returns the average rating
+  #
+  def rating
+    average = 0.0
+    ratings.each { |r|
+      average = average + r.rating
+    }
+    if ratings.size != 0
+      average = average / ratings.size
+    end
+    average
+  end
+
+  # Check to see if a user already rated this rateable
+  def rated_by_user?(user_name)
+    rtn = false
+    if user_name
+      self.ratings.each { |b|
+        rtn = true if user_name == b.user_name
+      }
+    end
+    rtn
+  end
+  def get_rating_by_user_name(user_name)
+    rtn = 0
+    if user_name
+      self.ratings.each { |b|
+        rtn = b.rating if user_name == b.user_name
+      }
+    end
+    rtn
+  end
+  def add_media_comment(user_name,comment)
+    newComment=Comment.new
+    newComment.mediaitem_id=self.id
+    newComment.content=comment
+    newComment.user_name=user_name
+    newComment.posted_time=Time.new.gmtime
+    newComment.save
+  end
+  def Mediaitem.add_media_comment(user_name,mediaitem_id,title,comment)
+
+    mediaitem=Mediaitem.find(mediaitem_id)
+    if mediaitem
+  
+      mediaitem.add_media_comment(user_name,comment)
+
+
+    end
+  end
+
+  def Mediaitem.convert_arg_to_mediaitem(mediaitem_arg)
+    item=nil
+    if mediaitem_arg.respond_to?(:HasImage)
+      item=mediaitem_arg
+    else
+      item=Mediaitem.find_by_guid(mediaitem_arg)
+    end
+    return item
+  end
+end

data/test/models/message.rb

@@ -0,0 +1,26 @@
+require "uri"
+
+require "not_relational/domain_model.rb"
+class Message < NotRelational::DomainModel
+    
+  property :id,:string,:is_primary_key=>true
+  property :title  , :string
+  property :content  , :clob
+  property :created_time_utc , :date
+  property :from_user_name , :string
+  property :to_user_name  , :string
+ 
+  
+  belongs_to :User,:from_user_name,:sender
+  belongs_to :User,:to_user_name,:recipient
+   def url
+          return "/messages/#{self.id}"
+  end
+   def Message.recent(how_many=24)
+      Message.find(:all,:limit=>how_many,:order_by =>:created_time_utc, :order=>:descending)
+  end
+  
+    def Message.inbox(login,how_many=32)
+      Message.find(:all,:limit=>how_many,:order_by =>:created_time_utc, :order=>:descending,:params=>{:to_user_name=>login})
+    end
+end