cloudwow-not_relational 0.1.0

data/test/models/album.rb

@@ -0,0 +1,206 @@
+require 'digest/sha1'
+require "uri"
+
+require "not_relational/domain_model.rb"
+require "active_support/inflector"
+
+class Album < NotRelational::DomainModel
+  property :id,:string,:is_primary_key=>true
+  property :guid , :string,:unique=>true
+  property :user_name , :string
+  property :title , :string
+  property :description , :clob 
+  property :created_time_utc ,:date  
+  property :last_update_time_utc ,:date  
+  property :is_private, :boolean
+  property :group_id, :string
+
+  index :group_and_title ,[:group_id,:title],:unique=>true
+  many_to_many :Mediaitem,:AlbumMediaItem,:album_id,:mediaitem_id,:mediaitems,:order_by=>:created_time
+  belongs_to :Group
+  
+     def Album.add_mediaitem(user_name,media_guid,album_guid,new_album_title=nil)
+  
+        mediaitem=Mediaitem.find_by_guid(media_guid)
+        if mediaitem
+            album=get_or_make_album(user_name,album_guid,new_album_title)
+ 
+              album.add_mediaitem(mediaitem)
+          
+            return album
+        end
+        return nil
+    end
+    def still_image_media
+      result=[]
+      for media_item in self.mediaitems
+        if !media_item.HasVideo && ! media_item.HasAudio
+          result<<media_item;
+        end
+      end
+        
+      return result
+    end
+    def video_media
+      result=[]
+      for media_item in self.mediaitems
+        if media_item.HasVideo 
+          result<<media_item;
+        end
+                  
+      end
+      return result
+    end
+    def audio_media
+      result=[]
+      for media_item in self.mediaitems
+        if media_item.HasAudio
+          result<<media_item;
+        end
+      
+      end
+    
+      return result
+    end
+    def  Album.create_group_album(user_name,group_id,title,description,is_private)
+          
+        album=Album.new
+        album.guid="#{NotRelational::UUID.generate.to_s}"
+        album.title=title
+        album.user_name=user_name
+        album.group_id=group_id
+        album.description=description
+        album.is_private=is_private
+        album.created_time_utc=Time.now.gmtime
+        album.save!
+      
+    
+        return album
+    end
+    def item_after(mediaitem)
+      previous=nil
+      for child in self.mediaitems
+        if previous && previous.id==mediaitem.id
+         return child
+        end
+        previous=child
+      end
+            
+    
+            
+      return nil
+    end
+        
+  
+    
+    def item_before(mediaitem)
+      
+      previous=nil
+     
+      self.mediaitems.each do |child|
+        if previous && child.id==mediaitem.id
+          return previous
+        end
+                
+        previous=child
+      end
+      
+      return nil
+    end
+    def recent(how_many=5)
+      result=self.mediaitems.reverse
+      if result.length>how_many
+        result=result.slice(0,how_many)
+      end
+      return result;
+    end
+    
+    def url
+      if group_id
+        raise "can't generate group urls from this API"
+      end
+      return "album/#{guid}/show.html"
+    end
+    def create_group_url(group_name)
+      return "#{Group.url_from_name(group_name)}/album/#{guid}"
+    end
+    def Album.create_group_url(group_name,album_guid)
+      return "#{Group.url_from_name(group_name)}/album/#{album_guid}"
+    end
+    
+    def create_group_edit_url(group_name)
+      return "#{create_group_url(group_name)}/edit"
+    end
+    def create_group_upload_url(group_name)
+      return "#{Group.url_from_name(group_name)}/album/#{guid}/upload"
+    end
+    def add_mediaitem(mediaitem)
+
+        self.last_update_time_utc=Time.now.gmtime
+        self.save           
+ 
+       old_item=AlbumMediaItem.find_connection(self.id,mediaitem.id)
+            if !old_item
+                newAlbumMediaItem=AlbumMediaItem.new
+                newAlbumMediaItem.album_id=self.id
+                newAlbumMediaItem.mediaitem_id=mediaitem.id
+                newAlbumMediaItem.save
+                
+            end
+
+    end
+      def Album.get_user_album(user_name,album_guid=nil)
+        if !album_guid
+            album_guid="useralbum:#{user_name}";
+        end
+        album=Album.find_by_guid(album_guid)
+        if !album
+            album=Album.new
+            album.guid=album_guid
+            album.user_name=user_name
+            album.created_time_utc=Time.now.gmtime
+            album.title="#{user_name.capitalize}'s media collection";
+            album.save
+        end
+        if album.user_name!=user_name and   album.user_name!= h(user_name)
+            raise "only album owner can submit to album"
+        end
+        return album
+    end
+    def  Album.get_or_make_album(user_name,album_guid,new_album_title=nil)
+          
+        if album_guid
+            album=Album.find_by_guid(album_guid)
+        end 
+        if !album
+            album=Album.new
+               
+            if album_guid
+                album.guid=album_guid
+            else
+                album.guid="#{UUID.generate.to_s}"
+            end
+            
+                 
+                
+            album.title=HtmlUtility.sanitize_html(new_album_title || "#{user_name.Capitalize}'s Media Collection").strip
+            album.user_name=user_name
+            album.created_time_utc=Time.now.gmtime
+      
+            album.save!
+           
+        end
+        return album
+    end
+    
+end
+class AlbumMediaItem < NotRelational::DomainModel
+    property :id,:string,:is_primary_key=>true
+    property :album_id , :string
+    property :mediaitem_id , :string
+    index :album_and_mediaitem,[:album_id,:mediaitem_id],:unique=>true
+    def AlbumMediaItem.find_connection(album_id,mediaitem_id)
+      AlbumMediaItem.find_by_album_and_mediaitem(album_id,mediaitem_id)
+    end
+    
+end

data/test/models/blurb.rb

@@ -0,0 +1,65 @@
+require 'digest/sha1'
+require "uri"
+
+require "not_relational/domain_model.rb"
+class Blurb < NotRelational::DomainModel
+    
+ property :namespace,:string,:is_primary_key=>true
+   property :name,:string,:is_primary_key=>true
+   property :description , :string  
+  
+  has_many :BlurbWording,:blurb_id
+    
+    def Blurb.get(namespace,name)
+        Blurb.find([namespace , name])
+
+    end
+     def get_wording(language=$language)
+         wording=BlurbWording.find([self.name ,self.namespace,language])
+           if !wording && language!='en'
+            
+                return self.get_wording('en')
+            
+            end
+           if !wording
+            return  self.name
+           end
+         return wording.text
+     end
+     def set_wording(language,text)
+        wording=BlurbWording.find([self.name ,self.namespace,language])
+         if !wording
+            wording=BlurbWording.new
+            wording.blurb_name=self.name
+            wording.blurb_namespace=self.namespace
+            wording.language_id=language
+         end
+         wording.text=text
+         wording.save
+         return wording
+         
+     end
+      def Blurb.set_wording(namespace,name,language,text)
+         blurb=Blurb.get(namespace,name)
+         if !blurb
+            blurb=Blurb.new
+            blurb.name=name
+            blurb.namespace=namespace
+            blurb.save!
+         end
+         blurb.set_wording(language,text)
+     end
+     
+     def Blurb.get_wording(namespace,name,language_id='en',default_value=nil)
+       result=BlurbWording.find([name ,namespace,language_id])
+      if result!=nil
+         return result.text
+      end
+      if   language_id=='en'
+        return default_value || name
+      end
+     return Blurb.get_wording(namespace,name,'en')
+   
+     end
+   
+end

data/test/models/blurb_wording.rb

@@ -0,0 +1,18 @@
+require 'digest/sha1'
+require "uri"
+
+require "not_relational/domain_model.rb"
+
+class BlurbWording < NotRelational::DomainModel
+  property :blurb_name,:string,:is_primary_key=>true
+  property :blurb_namespace,:string,:is_primary_key=>true
+  property :language_id , :string  ,:is_primary_key=>true
+  property :text,:clob
+  property :title , :string  
+  property :version , :string  
+  property :author , :string  
+  property :time_utc , :date
+  
+  belongs_to :Blurb,:blurb_name
+  
+end

data/test/models/comment.rb

@@ -0,0 +1,27 @@
+require "uri"
+
+require "not_relational/domain_model.rb"
+class Comment < NotRelational::DomainModel
+    
+  property :id,:string,:is_primary_key=>true
+  property :title  , :string
+  property :content  , :string
+  property :posted_time , :date
+  property :mediaitem_id , :string
+  property :parent_id  , :string
+  property :user_name , :string
+  property :namespace , :string
+ 
+  
+  belongs_to :Mediaitem
+  
+    def Comment.recent
+        Comment.find(:all, :limit => 16 ,:order_by =>:posted_time ,:order => :descending)
+  end
+    def Comment.recent_by_user(user_name)
+      Comment.find(:all, :limit => 16 ,:order_by =>:posted_time ,:order => :descending,:params => {:user_name=>user_name})
+    end
+   def user_url
+      return "/users/#{CGI.escape self.user_name}"
+    end
+end

data/test/models/error.rb

@@ -0,0 +1,14 @@
+require 'digest/sha1'
+require "uri"
+
+require "model/domain_model.rb"
+
+
+class Error < DomainModel
+  property :id,:string,:is_primary_key=>true
+ property :server,:string
+ property :message ,:string
+ property :stack_trace ,:string
+ property :time_utc ,:date 
+ 
+end

data/test/models/friend.rb

@@ -0,0 +1,27 @@
+require 'digest/sha1'
+require "uri"
+
+require "model/domain_model.rb"
+require "models/blurb.rb"
+
+class Friend < DomainModel
+  property :id,:string,:is_primary_key=>true
+   property :user_name,:string
+   property :friend_user_name,:string
+   property :created_time_utc,:date
+ belongs_to :User,:user_name,:user
+ belongs_to :User,:friend_user_name,:friend
+ index :user_name_and_friend_name,[:user_name,:friend_user_name],:unique=>true
+  def Friend.make_friend(user_name,friend_name)
+    existing_friend=Friend.find_by_user_name_and_friend_name(user_name.capitalize ,friend_name.capitalize)
+    if existing_friend==nil
+     newFriend=Friend.new
+        newFriend.user_name=user_name
+        newFriend.friend_user_name=friend_name
+        newFriend.created_time_utc=Time.now.gmtime
+        newFriend.save
+      return true
+    end
+      return false
+  end
+end

data/test/models/friend_request.rb

@@ -0,0 +1,34 @@
+require 'digest/sha1'
+require "uri"
+
+require "model/domain_model.rb"
+require "models/blurb.rb"
+
+class FriendRequest < DomainModel
+  property :id,:string,:is_primary_key=>true
+   property :user_name,:string
+   property :friend_user_name,:string
+   property :message,:clob
+   property :answer,:boolean
+   property :created_time_utc,:date
+ belongs_to :User,:user_name,:user
+ belongs_to :User,:friend_user_name,:friend_user
+ index :user_name_friend_name_and_answer_is_null,[:user_name,:friend_user_name,IsNullTransform.new(:answer)],:unique=>true
+ index :user_name_and_answer_is_null,[:user_name,IsNullTransform.new(:answer)]
+ index :friend_name_and_answer_is_null,[:friend_user_name,IsNullTransform.new(:answer)]
+  def FriendRequest.request_friendship(from_user_name,to_user_name,message)
+    old_request=    find_old_request(from_user_name,to_user_name)
+   return false if old_request!=nil
+    new_request=FriendRequest.new
+    new_request.user_name=from_user_name
+    new_request.friend_user_name=to_user_name
+    new_request.message=message
+    new_request.created_time_utc=Time.now.gmtime
+    new_request.save
+    return true
+  end
+  def FriendRequest.find_old_request(from_user_name,to_user_name)
+      FriendRequest.find_by_user_name_friend_name_and_answer_is_null(from_user_name,to_user_name,true)
+  end
+  
+end

data/test/models/geo.rb

@@ -0,0 +1,186 @@
+require "not_relational/starts_with_condition.rb"
+module NotRelational
+module Geo
+
+  class Location
+  
+
+    attr_accessor :latitude
+    attr_accessor :longitude
+    
+    def initialize(lat,lon)
+      self.latitude=lat
+      self.longitude=lon
+    end
+
+    def to_address
+	if latitude==nil || longitude==nil
+		return nil
+	end      
+	address='t'
+      right=0
+      top=0
+      width=180.0
+      height=90.0
+      16.times do
+
+        if latitude>top
+          top=top+height/2.0
+          if longitude<right
+            right=right-width/2.0
+            address<<'q'
+          else
+            right=right+width/2.0
+            address << 'r'
+          end
+        else
+
+          top=top-height/2.0
+          if longitude<right
+            right=right-width/2.0
+            address<<'t'
+          else
+            right=right+width/2.0
+            address << 's'
+          end
+        end
+        width=width/2.0
+        height=height/2.0
+    #    puts "#{address} w=#{width}  h=#{height} r=#{right}  t=#{top}"
+      end
+      return address
+    end
+    def get_nearby_addresses(zoom_level)
+      address=self.to_address
+      if address.length>(zoom_level+1)
+        address=address.slice(0,zoom_level+1)        
+      end
+      
+      result=[address]
+      
+      tileWidth=360.0/(2**zoom_level)
+      tileHeight=180.0/(2**zoom_level)
+
+      other=Geo::Location.new(self.latitude+tileHeight,self.longitude+tileWidth)
+      result << other.to_address.slice(0,zoom_level+1)
+
+      other=Geo::Location.new(self.latitude+tileHeight,self.longitude)
+      result << other.to_address.slice(0,zoom_level+1)
+
+      other=Geo::Location.new(self.latitude+tileHeight,self.longitude-tileWidth)
+      result << other.to_address.slice(0,zoom_level+1)
+
+      other=Geo::Location.new(self.latitude-tileHeight,self.longitude+tileWidth)
+      result << other.to_address.slice(0,zoom_level+1)
+
+      other=Geo::Location.new(self.latitude-tileHeight,self.longitude)
+      result << other.to_address.slice(0,zoom_level+1)
+
+      other=Geo::Location.new(self.latitude-tileHeight,self.longitude-tileWidth)
+      result << other.to_address.slice(0,zoom_level+1)
+
+
+      other=Geo::Location.new(self.latitude,self.longitude+tileWidth)
+      result << other.to_address.slice(0,zoom_level+1)
+
+      other=Geo::Location.new(self.latitude,self.longitude-tileWidth)
+      result << other.to_address.slice(0,zoom_level+1)
+
+
+    end
+    def  Location.to_location(address)
+      width=90.0
+      height=45.0
+
+      index=0
+      x=0
+      y=0
+      length=address.length-1
+      length.times do
+        index+=1
+
+        puts address[index].chr
+        case address[index].chr
+
+           when 'r'
+            x+=width
+            y+=height
+           when 'q'
+            x-=width
+            y+=height
+
+           when 't'
+            x-=width
+            y-=height
+           when 's'
+            x+=width
+            y-=height
+        end
+        width/=2
+        height/=2
+      end
+        loc=Location.new
+      loc.latitude=y
+      loc.longitude=x
+      return loc
+    end
+
+    def self.deg2rad(deg)
+      (deg * Math::PI / 180)
+      end
+    
+    def self.rad2deg(rad)
+      (rad * 180 / Math::PI)
+    end
+    
+    def self.acos(rad)
+      Math.atan2(Math.sqrt(1 - rad**2), rad)
+    end
+    
+    def distance_in_miles( loc2)
+      lat2 = loc2.latitude
+      lon2 = loc2.longitude
+      theta = self.longitude - lon2
+      
+      dist = Math.sin(self.deg2rad(self.latitude)) * Math.sin(deg2rad(lat2)) + Math.cos(self.deg2rad(self.latitude)) * Math.cos(self.deg2rad(lat2)) * Math.cos(deg2rad(theta))
+      
+      dist = self.rad2deg(self.acos(dist))
+      
+      (dist * 60 * 1.1515).round #distance in miles
+    end
+    
+  end
+
+#mixin
+#locatable object must have latitude, longitude and address attributes
+  module Locatable
+    def location
+      return Geo::Location.new(latitude,longitude)
+    end
+    def get_nearby(zoom_level=7,order=nil)
+       if latitude==nil or longitude==nil 
+	return []
+	end
+	result= self.class.find_near(self.location,zoom_level,order)
+        result.delete_if{|item|item.id==id}
+        return result
+    end
+
+    def find_near(loc,zoom_level=7,order_by=nil,order=:ascending)
+        nearby= loc.get_nearby_addresses(zoom_level)
+
+        address_params=[]
+        for address in nearby
+            
+                 address_params<<NotRelational::StartsWithCondition.new(self.AttributeDescription(:address),address)
+       
+        end
+       orCondition=OrCondition.new(address_params)
+      
+        return find(:all,:limit => 24,:order_by => order_by,:order => order,:conditions=>[orCondition])
+      
+    end
+  end
+  
+end
+end