rhodes 3.3.1 → 3.3.2.beta.1

data/platform/wp7/RhoRubyLib/db/DBAdapter.cs

@@ -107,10 +107,47 @@ namespace rho.db
         }
     }
 
+    public static void SyncBlob_DeleteSchemaCallback(Sqlite3.sqlite3_context dbContext, int nArgs, Sqlite3.Mem[] Args)
+    {
+        String value = Sqlite3.sqlite3_value_text(Args[0]);
+        if (value == null) return;
+        String strFilePath = RHODESAPP().resolveDBFilesPath(value);
+        if (strFilePath != "")
+            CRhoFile.deleteFile(strFilePath);
+    }
+
+    public static void SyncBlob_UpdateSchemaCallback(Sqlite3.sqlite3_context dbContext, int nArgs, Sqlite3.Mem[] Args)
+    {
+        String szOldValue = Sqlite3.sqlite3_value_text(Args[0]);
+        String szNewValue = Sqlite3.sqlite3_value_text(Args[1]);
+        
+        if ( szOldValue == szNewValue || szOldValue == null )
+            return;
+
+        if ( szOldValue != null && szNewValue != null &&  szOldValue == szNewValue )
+            return;
+
+        if (szOldValue != null)
+        {
+            String strFilePath = RHODESAPP().resolveDBFilesPath(szOldValue);
+            CRhoFile.deleteFile(strFilePath);
+        }
+    }
+
 	private void setDbPartition(String strPartition)
 	{
 		m_strDbPartition = strPartition;
 	}
+
+    public void createTrigger(String strSQL)
+    {
+        m_dbStorage.createTrigger(strSQL);
+    }
+
+    public void dropTrigger(String strName)
+    {
+        m_dbStorage.dropTrigger(strName);
+    }
 	 
 	public void close()
 	{ 

data/platform/wp7/RhoRubyLib/db/DBAttrManager.cs

@@ -26,6 +26,7 @@
 
 using System;
 using rho.common;
+using System.Collections.Generic;
 
 namespace rho.db
 {
@@ -73,7 +74,68 @@ namespace rho.db
     public void loadBlobAttrs(DBAdapter db)
     {
         loadAttrs(db, m_mapBlobAttrs, "blob_attribs", m_mapSrcNames);
-        //TODO: update/delete trigger for schema sources
+
+        String strTriggerPrefix = "rhoSchemaTrigger_";
+        IDBResult res = db.executeSQL("SELECT name FROM sqlite_master WHERE type='trigger'");
+        Hashtable<String, int> mapTriggers = new Hashtable<String, int>();
+        for (; !res.isEnd(); res.next())
+        {
+            String strName = res.getStringByIdx(0);
+            if (!strName.startsWith(strTriggerPrefix))
+                continue;
+
+            mapTriggers[strName.Substring(strTriggerPrefix.length())] = 0;
+        }
+
+        foreach (KeyValuePair<int, Hashtable<String,int>> kvpBlobAttrs in m_mapBlobAttrs)
+        {
+            int nSrcID = kvpBlobAttrs.Key;
+
+            res = db.executeSQL("SELECT name FROM sources WHERE source_id=?", nSrcID);
+            if ( res.isEnd() )
+                continue;
+
+            String strName = res.getStringByIdx(0);
+            if ( !db.isTableExist(strName) )
+                continue;
+
+            Hashtable<String,int> hashAttribs = kvpBlobAttrs.Value;
+            foreach (KeyValuePair<String, int> kvpHashAttribs in hashAttribs)
+            {
+                String strTriggerName = strName + "_" + kvpHashAttribs.Key;
+                if ( !mapTriggers.containsKey(strTriggerName + "_delete") )
+                {
+                    String strTrigger = "CREATE TRIGGER " + strTriggerPrefix + strTriggerName + "_delete BEFORE DELETE ON \"" + strName + "\" FOR EACH ROW \r\n"
+                    +"   BEGIN \r\n"
+                    + "       SELECT rhoOnDeleteSchemaRecord( OLD." + kvpHashAttribs.Key + ");\r\n"
+                    +"   END;\r\n"
+                    +";";
+
+                    db.createTrigger(strTrigger);
+                }else
+                    mapTriggers[strTriggerName + "_delete"] = 1;
+
+                if ( !mapTriggers.containsKey(strTriggerName + "_update") )
+                {
+                    String strTrigger = "CREATE TRIGGER " + strTriggerPrefix + strTriggerName + "_update BEFORE UPDATE ON \"" + strName + "\" FOR EACH ROW\r\n"
+                    +"   BEGIN \r\n"
+                    + "       SELECT rhoOnUpdateSchemaRecord( OLD." + kvpHashAttribs.Key + ", NEW." + kvpHashAttribs.Key + ");\r\n"
+                    +"   END;\r\n"
+                    +";";
+
+                    db.createTrigger(strTrigger);
+                }else
+                    mapTriggers[strTriggerName + "_update"] = 1;
+
+                }
+        }
+
+        //Remove outdated triggers
+        foreach (KeyValuePair<string, int> kvp in mapTriggers)
+        {
+            if(kvp.Value != 0)
+                db.dropTrigger(strTriggerPrefix+kvp.Key.ToString());
+        }
     }
     
     static void loadAttrs(DBAdapter db, Hashtable< int, Hashtable<String,int> > mapAttrs, String strDBAttr,

data/platform/wp7/RhoRubyLib/db/IDBStorage.cs

@@ -54,5 +54,7 @@ namespace rho.db
 	
         boolean isDbFileExists(String strPath);
         void createTriggers();
+        void createTrigger(String strSQL);
+        void dropTrigger(String strName);
     }
 }

data/platform/wp7/RhoRubyLib/db/SqliteStorage.cs

@@ -107,6 +107,29 @@ namespace rho.db
             }
         }
 
+        public void createTrigger(String strSQL)
+        {
+            int res = Sqlite3.sqlite3_exec(m_db, strSQL, 0, 0, 0);
+            if (res != Sqlite3.SQLITE_OK)
+            {
+                Sqlite3.sqlite3_close(m_db);
+                m_db = null;
+                throw new DBException(res, "Cannot create trigger: " + strSQL);
+            }
+        }
+
+        public  void dropTrigger(String strName)
+        {
+            String strSQL = "DROP TRIGGER " + strName + ";";
+            int res = Sqlite3.sqlite3_exec(m_db, strSQL, 0, 0, 0);
+            if (res != Sqlite3.SQLITE_OK)
+            {
+                Sqlite3.sqlite3_close(m_db);
+                m_db = null;
+                throw new DBException(res, "Cannot drop trigger: " + strName);
+            }
+        }
+
         void checkError()
         {
             int res = Sqlite3.sqlite3_errcode(m_db);
@@ -216,6 +239,10 @@ namespace rho.db
                                                 DBAdapter.SyncBlob_DeleteCallback, null, null);
                 Sqlite3.sqlite3_create_function(m_db, "rhoOnUpdateObjectRecord", 3, Sqlite3.SQLITE_ANY, 0,
                                                 DBAdapter.SyncBlob_UpdateCallback, null, null);
+                Sqlite3.sqlite3_create_function(m_db, "rhoOnDeleteSchemaRecord", 1, Sqlite3.SQLITE_ANY, 0,
+                                                DBAdapter.SyncBlob_DeleteSchemaCallback, null, null);
+                Sqlite3.sqlite3_create_function(m_db, "rhoOnUpdateSchemaRecord", 2, Sqlite3.SQLITE_ANY, 0,
+                                                DBAdapter.SyncBlob_UpdateSchemaCallback, null, null);
 
                 string[] ar2 = CRhoFile.enumDirectory("db");
 

data/platform/wp7/RhoRubyLib/logging/RhoLogServerSink.cs

@@ -68,8 +68,8 @@ namespace rho.logging
         {
             IDictionary<object, object> map = new Dictionary<object, object>();
             Hash values = new Hash(map);
-            values.Add(MutableString.Create("url"), MutableString.Create(m_addrHost));
-            values.Add(MutableString.Create("body"), MutableString.Create(strMsg));
+            values.Add(CRhoRuby.CreateSymbol("url"), MutableString.Create(m_addrHost));
+            values.Add(CRhoRuby.CreateSymbol("body"), MutableString.Create(strMsg));
             RhoParams p = new RhoParams(values);
             m_aHttp.addHttpCommand(new CAsyncHttp.HttpCommand("POST", p));
         }

data/platform/wp7/RhoRubyLib/net/NetRequest.cs

@@ -100,9 +100,10 @@ namespace rho.net
                 Hashtable<String, String>.Enumerator hashEnum = headers.GetEnumerator();
 		        while( hashEnum.MoveNext() )
 		        {
-				    String strName = hashEnum.Current.Key;
+                    String strName = hashEnum.Current.Key.Replace(" ", "").Replace("-", "");
 				    String strValue = hashEnum.Current.Value;
-                    m_webRequest.Headers[strName.Replace("-", "")] = strValue;
+                    m_webRequest.Headers[strName] = strValue;
+                    if (strName == "ContentType") m_webRequest.ContentType = strValue;
 		        }
 			
 		    }
@@ -510,7 +511,7 @@ namespace rho.net
 		    NetResponse pResp = new NetResponse(strRespBody != null ? strRespBody : "", nErrorCode );
             if (pResp.isSuccess())
             {
-                if (m_strCookies == "" && m_strRespBody.Contains("rhoconnect_session"))
+                if (m_strCookies == "" && m_strRespBody != null && m_strRespBody.Contains("rhoconnect_session"))
                 {
                     m_strRespBody = m_strRespBody.Replace('{', ' ');
                     m_strRespBody = m_strRespBody.Replace('}', ' ');

data/platform/wp7/RhoRubyLib/rubyext/RhoAlert.cs

@@ -0,0 +1,160 @@
+/*------------------------------------------------------------------------
+* (The MIT License)
+* 
+* Copyright (c) 2008-2011 Rhomobile, Inc.
+* 
+* 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.
+* 
+* http://rhomobile.com
+*------------------------------------------------------------------------*/
+
+using Microsoft.Scripting.Utils;
+using Microsoft.Scripting.Runtime;
+using IronRuby.Runtime;
+using IronRuby.Builtins;
+using System;
+using System.Runtime.InteropServices;
+using Coding4Fun.Phone.Controls;
+using System.Windows.Controls;
+using System.Windows;
+using rho.common;
+
+namespace rho.rubyext
+{
+    [RubyModule("Alert")]
+    public static class RhoAlert
+    {
+        private static RhoLogger LOG = RhoLogger.RHO_STRIP_LOG ? new RhoEmptyLogger() :
+            new RhoLogger("RhoAlert");
+        private static CRhoRuby RhoRuby { get { return CRhoRuby.Instance; } }
+        private static CRhodesApp RHODESAPP() { return CRhodesApp.Instance; }
+        private static MessagePrompt m_messagePrompt = null;
+        private static String m_callback = "";
+        private static int m_buttonId = 0;
+        private static String m_buttonTitle = "";
+
+        #region Private Implementation Details
+
+        #endregion
+
+        #region Private Instance & Singleton Methods
+
+        [RubyMethodAttribute("show_popup", RubyMethodAttributes.PublicSingleton)]
+        public static void ShowPopup(RubyModule/*!*/ self, Object args)
+        {
+            String message = "";
+            String title = "";
+            Object[] buttons = null;
+            object val = null;
+
+            if (args != null && args is MutableString)
+            {
+                message = ((MutableString)args).ToString();
+                buttons = new String[1];
+                buttons[0] = "Ok";
+            }
+            if (args != null && args is Hash && ((Hash)args).TryGetValue(CRhoRuby.CreateSymbol("title"), out val))
+                title = val.ToString();
+            if (args != null && args is Hash && ((Hash)args).TryGetValue(CRhoRuby.CreateSymbol("message"), out val))
+                message = val.ToString();
+            if (args != null && args is Hash && ((Hash)args).TryGetValue(CRhoRuby.CreateSymbol("callback"), out val))
+                m_callback = val.ToString();
+            if (args != null && args is Hash && ((Hash)args).TryGetValue(CRhoRuby.CreateSymbol("buttons"), out val) && val is RubyArray)
+                buttons = ((RubyArray)val).ToArray();
+
+            RHODESAPP().MainPage.Dispatcher.BeginInvoke(() =>
+            {
+                m_messagePrompt = new MessagePrompt
+                {
+                    Title = title,
+                    Message = message
+                };
+                m_messagePrompt.Completed += messagePrompt_Completed;
+                m_messagePrompt.ActionPopUpButtons.Clear();
+                for (int i = 0; buttons != null && i < buttons.Length; i++)
+                {
+                    if (buttons[i] != null)
+                    {
+                        Button customButton = new Button();
+                        if(buttons[i] is Hash)
+                        {
+                            ((Hash)buttons[i]).TryGetValue(CRhoRuby.CreateSymbol("title"), out val);
+                            if(val != null)
+                                customButton.Content = val;
+                        }
+                        else
+                            customButton.Content = buttons[i];
+                        customButton.Click += new RoutedEventHandler(customButton_Click);
+                        m_messagePrompt.ActionPopUpButtons.Add(customButton);
+                    }
+                }
+                m_messagePrompt.Show();
+            });
+    
+        }
+
+        [RubyMethodAttribute("hide_popup", RubyMethodAttributes.PublicSingleton)]
+        public static void HidePopup(RubyModule/*!*/ self)
+        {
+            RHODESAPP().MainPage.Dispatcher.BeginInvoke(() =>
+            {
+                if (m_messagePrompt != null)
+                    m_messagePrompt.Hide();
+            });
+        }
+
+        [RubyMethodAttribute("vibrate", RubyMethodAttributes.PublicSingleton)]
+        public static void Vibrate(RubyModule/*!*/ self, int duration)
+        {
+        }
+
+        [RubyMethodAttribute("play_file", RubyMethodAttributes.PublicSingleton)]
+        public static void PlayFile(RubyModule/*!*/ self, [NotNull]String/*!*/ fileName, [NotNull]String/*!*/ mediaType)
+        {
+        }
+
+        [RubyMethodAttribute("show_status", RubyMethodAttributes.PublicSingleton)]
+        public static void ShowStatus(RubyModule/*!*/ self, [NotNull]String/*!*/ title, [NotNull]String/*!*/ text, String/*!*/ hideLabel)
+        {
+        }
+
+        #endregion
+
+        private static void customButton_Click(object sender, RoutedEventArgs e)
+        {
+            if (m_messagePrompt != null)
+            {
+                m_buttonTitle = ((Button)sender).Content.ToString();
+                m_buttonId = m_messagePrompt.ActionPopUpButtons.IndexOf((Button)sender);
+                m_messagePrompt.Hide();
+            }
+        }
+
+        private static void messagePrompt_Completed(object sender, PopUpEventArgs<string, PopUpResult> e)
+        {
+            if (m_callback != "")
+            {
+                m_callback = RHODESAPP().canonicalizeRhoUrl(m_callback);
+                RhoClassFactory.createNetRequest().pushData(m_callback, "button_id="+m_buttonId.ToString()+"&button_title="+m_buttonTitle+"&rho_callback=1", null);
+            }
+        }
+
+
+    }
+}

data/platform/wp7/RhoRubyLib/rubyext/RhoSyncEngine.cs

@@ -43,12 +43,24 @@ namespace rho.rubyext
         static CRhoRuby RhoRuby { get { return CRhoRuby.Instance; } }
 
         [RubyMethod("dosync", RubyMethodAttributes.PublicSingleton)]
-        public static object dosync(RubyModule/*!*/ self)
+        public static object dosync(RubyModule/*!*/ self, RubyArray args)
         {
             object res = null;
             try
             {
-                SyncThread.getInstance().addQueueCommand(new SyncThread.SyncCommand(SyncThread.scSyncAll, false));
+                boolean bShowStatus = true;	
+                String query_params = "";
+                if ( args != null && args.Count > 0 )	
+                {
+                    String str = ((MutableString)args[0]).ToString();	
+                    //bShowStatus = args[0].Equals(RubyConstant.QTRUE)||"true".equalsIgnoreCase(str);	
+                    bShowStatus = "true".equalsIgnoreCase(str);	
+                }
+        
+                if (args != null && args.Count > 1)
+                    query_params = ((MutableString)args[1]).ToString();
+                
+                SyncThread.getInstance().addQueueCommand(new SyncThread.SyncCommand(SyncThread.scSyncAll, bShowStatus, query_params));
 
                 res = SyncThread.getInstance().getRetValue();
             }
@@ -66,8 +78,8 @@ namespace rho.rubyext
             return res;
         }
 
-        [RubyMethod("dosync", RubyMethodAttributes.PublicSingleton)]
-        public static object dosync(RubyModule/*!*/ self, bool/*!*/ show_status_popup)
+        /*[RubyMethod("dosync", RubyMethodAttributes.PublicSingleton)]
+        public static object dosync(RubyModule self, bool show_status_popup)
         {
             object res = null;
             try
@@ -88,24 +100,44 @@ namespace rho.rubyext
             }
 
             return res;
-        }
+        }*/
 
         [RubyMethod("dosync_source", RubyMethodAttributes.PublicSingleton)]
-        public static object dosync_source(RubyModule/*!*/ self, [NotNull]object/*!*/ srcID)
+        public static object dosync_source(RubyModule/*!*/ self, RubyArray args)
         {
             object res = null;
             try
             {
                 int nSrcID = 0;
                 String strName = "";
-                if (srcID is long)
+
+                if ( args[0] is  long)
+                    nSrcID = (int)(long)args[0];
+                else if (args[0] is int)
+                    nSrcID = (int)args[0];
+                else
+                    strName = ((MutableString)args[0]).ToString();
+
+                /*if (srcID is long)
                     nSrcID = (int)(long)srcID;
                 else if (srcID is int)
                     nSrcID = (int)srcID;
                 else
-                    strName = srcID.ToString();
+                    strName = srcID.ToString();*/
+
+                boolean bShowStatus = true;	
+                String query_params = "";
+                if ( args != null && args.Count > 1 )	
+                {
+                    String str = ((MutableString)args[1]).ToString();	
+                    //bShowStatus = args[0].Equals(RubyConstant.QTRUE)||"true".equalsIgnoreCase(str);	
+                    bShowStatus = "true".equalsIgnoreCase(str);	
+                }
+        
+                if (args != null && args.Count > 2)
+                    query_params = ((MutableString)args[2]).ToString();
 
-                SyncThread.getInstance().addQueueCommand(new SyncThread.SyncCommand(SyncThread.scSyncOne, strName, nSrcID, true));
+                SyncThread.getInstance().addQueueCommand(new SyncThread.SyncCommand(SyncThread.scSyncOne, strName, nSrcID, bShowStatus, query_params));
 
                 res = SyncThread.getInstance().getRetValue();
             }
@@ -123,8 +155,8 @@ namespace rho.rubyext
             return res;
         }
         
-        [RubyMethod("dosync_source", RubyMethodAttributes.PublicSingleton)]
-        public static object dosync_source(RubyModule/*!*/ self, [NotNull]object/*!*/ srcID, bool/*!*/ show_status_popup)
+        /*[RubyMethod("dosync_source", RubyMethodAttributes.PublicSingleton)]
+        public static object dosync_source(RubyModule self, [NotNull]object srcID, bool show_status_popup)
         {
             object res = null;
             try
@@ -154,7 +186,7 @@ namespace rho.rubyext
             }
 
             return res;
-        }
+        }*/
 
         [RubyMethod("dosearch", RubyMethodAttributes.PublicSingleton)]
         public static object dosearch(RubyModule/*!*/ self, [NotNull]RubyArray/*!*/ arSourcesR, [NotNull]String/*!*/ from, [NotNull]String/*!*/ strParams,