Exemplo n.º 1
0
        /// <summary>
        /// Copies the LM.
        /// </summary>
        /// <returns></returns>
        /// <remarks>Documented by Dev07, 2009-05-20</remarks>
        public static bool CopyLM(string source, string destination)
        {
            try
            {
                string filename = destination;
                if (File.Exists(filename))
                {
                    int i = 0;
                    while (File.Exists(filename.Replace(".mlm", "_" + i + ".mlm")))
                    {
                        i++;
                    }
                    filename = filename.Replace(".mlm", "_" + i + ".mlm");
                }

                string      sourceConString = MSSQLCEConn.GetFullConnectionString(source);
                string      desConString    = MSSQLCEConn.GetFullConnectionString(filename);
                SqlCeEngine engine          = new SqlCeEngine(sourceConString);
                engine.Compact(desConString);
                engine.Dispose();
            }
            catch (Exception e)
            {
                Trace.WriteLine(e.ToString());
                return(false);
            }
            return(true);
        }
Exemplo n.º 2
0
        private int FindAC_ID_Type(string type, string permissionName, string roleId, bool bIsGroup)
        {
            string XXX_AccessControlList;
            string XXX_RoleId;
            int    ac_id;

            if (bIsGroup)
            {
                XXX_AccessControlList = "UserGroups_AccessControlList";
                XXX_RoleId            = "groups_id";
            }
            else
            {
                XXX_AccessControlList = "UserProfiles_AccessControlList";
                XXX_RoleId            = "users_id";
            }
            //Suche entsprechende ac_id
            using (SqlCeCommand cmd = MSSQLCEConn.CreateCommand(m_User))
            {
                cmd.CommandText =
                    string.Format("SELECT al.id FROM \"AccessControlList\" AS al INNER JOIN \"{0}\" AS ua ON ua.acl_id = al.id ", XXX_AccessControlList) +
                    "INNER JOIN \"Permissions\" AS pe ON al.permissions_id = pe.id INNER JOIN \"TypeDefinitions\" AS td ON pe.types_id = td.id INNER JOIN \"ObjectList\" AS ol ON ol.id=al.object_id " +
                    string.Format("WHERE ua.{0} = {1} AND pe.name = '{2}' AND td.clr_name='{3}' AND ol.locator='DUMMYOBJECT'",
                                  XXX_RoleId, roleId, permissionName, type);


                object result = cmd.ExecuteScalar();
                ac_id = (result == null || result is System.DBNull) ? -1 : (int)result;
                //ac_id = (int)cmd.ExecuteScalar();
            }
            return(ac_id);
        }
Exemplo n.º 3
0
 /// <summary>
 /// Gets the default permission for a type.
 /// </summary>
 /// <param name="type">The type.</param>
 /// <param name="permissionName">Name of the permission.</param>
 /// <returns></returns>
 /// <remarks>Documented by Dev03, 2009-02-27</remarks>
 public bool _GetDefaultPermissionOfType(string type, string permissionName)
 {
     using (SqlCeCommand cmd = MSSQLCEConn.CreateCommand(m_User))
     {
         cmd.CommandText = "SELECT pe.\"default\" FROM Permissions AS pe INNER JOIN TypeDefinitions AS td ON pe.types_id = td.id WHERE td.clr_name = @clr_name AND pe.name = @permission";
         cmd.Parameters.Add("@clr_name", type);
         cmd.Parameters.Add("@permission", permissionName);
         object result = cmd.ExecuteScalar();
         return((result == null || result is System.DBNull) ? false : (bool)result);
     }
 }
Exemplo n.º 4
0
        /// <summary>
        /// Gets the users permission for an object.
        /// </summary>
        /// <param name="locator">The locator.</param>
        /// <param name="type">The type.</param>
        /// <param name="permissionName">Name of the permission.</param>
        /// <param name="userId">The user id.</param>
        /// <returns></returns>
        /// <remarks>Documented by Dev03, 2009-02-27</remarks>
        public bool?_GetPermissionOfUserObjectPermissionList(string locator, string type, string permissionName, string userId)
        {
            using (SqlCeCommand cmd = MSSQLCEConn.CreateCommand(m_User))
            {
                cmd.CommandText = "SELECT al.access FROM \"AccessControlList\" AS al INNER JOIN \"UserProfiles_AccessControlList\" AS ua ON ua.acl_id = al.id " +
                                  "INNER JOIN \"Permissions\" AS pe ON al.permissions_id = pe.id INNER JOIN \"TypeDefinitions\" AS td ON pe.types_id = td.id  INNER JOIN \"ObjectList\" AS ol ON ol.id=al.object_id " +
                                  string.Format("WHERE ua.users_id = {0} AND pe.name = '{1}' AND ol.locator = '{2}' AND td.clr_name='{3}'", userId, permissionName, locator, type);

                object result = cmd.ExecuteScalar();
                return((result == null || result is System.DBNull) ? (bool?)null : (bool?)result);
            }
        }
Exemplo n.º 5
0
 /// <summary>
 /// Gets the users permission for a type.
 /// </summary>
 /// <param name="type">The type.</param>
 /// <param name="permissionName">Name of the permission.</param>
 /// <param name="userId">The user id.</param>
 /// <returns></returns>
 /// <remarks>Documented by Dev03, 2009-02-27</remarks>
 public bool?_GetPermissionOfUserTypePermissionList(string type, string permissionName, string userId)
 {
     using (SqlCeCommand cmd = MSSQLCEConn.CreateCommand(m_User))
     {
         cmd.CommandText = "SELECT al.access FROM \"AccessControlList\" AS al INNER JOIN \"UserProfiles_AccessControlList\" AS ua ON ua.acl_id = al.id " +
                           "INNER JOIN \"Permissions\" AS pe ON al.permissions_id = pe.id INNER JOIN \"TypeDefinitions\" AS td ON pe.types_id = td.id INNER JOIN \"ObjectList\" AS ol ON ol.id=al.object_id " +
                           "WHERE ua.users_id = @user_id AND pe.name = @permission AND ol.locator = 'DUMMYOBJECT' AND td.clr_name = @clr_name";
         cmd.Parameters.Add("@user_id", userId);
         cmd.Parameters.Add("@permission", permissionName);
         cmd.Parameters.Add("@clr_name", type);
         object result = cmd.ExecuteScalar();
         return((result == null || result is System.DBNull) ? (bool?)null : (bool?)result);
     }
 }
Exemplo n.º 6
0
 public int GetIdByLocator(string locator)
 {
     //Lösche nun noch in der UserGroups_AccessControlList
     using (SqlCeCommand cmd = MSSQLCEConn.CreateCommand(m_User))
     {
         cmd.CommandText = string.Format("SELECT id FROM ObjectList WHERE locator='{0}'", locator);
         object result = null;
         using (SqlCeDataReader reader = cmd.ExecuteReader())
         {
             if (reader.Read())
             {
                 result = reader["id"];
             }
         }
         return((result == null || result is System.DBNull) ? -1 : (int)result);
     }
 }
Exemplo n.º 7
0
        public void Refresh()
        {
            this.Clear();

            using (SqlCeCommand cmd = MSSQLCEConn.CreateCommand(m_User))
            {
                cmd.CommandText = "SELECT users_id,groups_id FROM UserProfiles_UserGroups";
                SqlCeDataReader reader = cmd.ExecuteReader();

                while (reader.Read())
                {
                    UserProfile_UserGroups entry = new UserProfile_UserGroups();
                    entry.UserId  = Convert.ToInt32(reader["users_id"]);
                    entry.GroupId = Convert.ToInt32(reader["groups_id"]);
                    this.Add(entry);
                }
            }
        }
Exemplo n.º 8
0
        public void Refresh()
        {
            this.Clear();
            using (SqlCeCommand cmd = MSSQLCEConn.CreateCommand(m_User))
            {
                cmd.CommandText = "SELECT id, name FROM UserGroups";
                SqlCeDataReader reader = cmd.ExecuteReader();

                while (reader.Read())
                {
                    UserGroup userGroup = new UserGroup();
                    userGroup.Id   = Convert.ToInt32(reader["id"]);
                    userGroup.Name = reader["name"].ToString();

                    this.Add(userGroup.Id, userGroup);
                }
            }
        }
Exemplo n.º 9
0
        public void Refresh()
        {
            this.Clear();
            using (SqlCeCommand cmd = MSSQLCEConn.CreateCommand(m_User))
            {
                cmd.CommandText = "SELECT id,name, types_id,\"default\" FROM Permissions";
                SqlCeDataReader reader = cmd.ExecuteReader();

                while (reader.Read())
                {
                    Permission info = new Permission();
                    info.Id             = Convert.ToInt32(reader["id"]);
                    info.PermissionName = reader["name"].ToString();
                    info.TypeId         = Convert.ToInt32(reader["types_id"]);
                    info.DefaultAccess  = Convert.ToBoolean(reader["default"]);
                    this.Add(info.Id, info);
                }
            }
        }
Exemplo n.º 10
0
        /// <summary>
        /// Resets the users permission for an object.
        /// </summary>
        /// <param name="locator">The locator.</param>
        /// <param name="type">The type.</param>
        /// <param name="userId">The user id.</param>
        /// <remarks>Documented by Dev03, 2009-02-27</remarks>
        public void _ResetUserObjectPermission(string locator, string type, string userId)
        {
            int type_id = Adapters.TypeDefinitionsAdapter.GetIdByTypeName(type);

            //suche alle acl_id Einträge in UserGroups_AccessControlList mit groups_id
            //lösche alle Einträge in der AccessControlList mit id == acl_id eines Typs
            int user_id = int.Parse(userId);

            List <int> acl_ids    = new List <int>();
            List <int> object_ids = new List <int>();

            using (SqlCeCommand cmd = MSSQLCEConn.CreateCommand(m_User))
            {
                cmd.CommandText = "SELECT upacl.acl_id,acl.object_id FROM \"UserProfiles_AccessControlList\" as upacl " +
                                  "INNER JOIN \"AccessControlList\" AS acl ON acl.id=upacl.acl_id " +
                                  "INNER JOIN \"Permissions\"  AS pe ON pe.id=acl.permissions_id " +
                                  "INNER JOIN \"ObjectList\" AS ol ON ol.id=acl.object_id " +
                                  "WHERE upacl.users_id=@users_id AND pe.types_id=@type_id AND ol.locator=@locator";
                cmd.Parameters.Add("@users_id", user_id);
                cmd.Parameters.Add("@type_id", type_id);
                cmd.Parameters.Add("@locator", locator);
                using (SqlCeDataReader dr = cmd.ExecuteReader())
                {
                    while (dr.Read())
                    {
                        acl_ids.Add((int)dr["acl_id"]);
                        object_ids.Add((int)dr["object_id"]);
                    }
                }
            }
            foreach (int object_id in object_ids)
            {
                Adapters.ObjectListAdapter.RemoveEntry(object_id);
            }
            foreach (int acl_id in acl_ids)
            {
                Adapters.UserProfiles_AccessControlListAdapter.RemoveEntry(user_id, acl_id);
            }
            foreach (int acl_id in acl_ids)
            {
                Adapters.AccessControlListAdapter.RemoveEntryById(acl_id);
            }
        }
Exemplo n.º 11
0
        /// <summary>
        /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
        /// </summary>
        /// <remarks>Documented by Dev03, 2009-01-13</remarks>
        public void Dispose()
        {
            if (DbMediaServer.DbMediaServer.Instance(parent).IsAlive)
            {
                DbMediaServer.DbMediaServer.Instance(parent).Stop();
            }

            if (Parent != null)
            {
                Parent.OnDictionaryClosed(this, EventArgs.Empty);
            }

            if (Parent.CurrentUser.ConnectionString.Typ == DatabaseType.MsSqlCe)
            {
                MSSQLCEConn.CloseMyConnection(this.Connection);
            }
            //MSSQLCEConn.CloseAllConnections();

            FileCleanupQueue.DoCleanup();
        }
Exemplo n.º 12
0
 /// <summary>
 /// Creates a new extension file.
 /// </summary>
 /// <remarks>Documented by Dev07, 2009-07-06</remarks>
 public void Create()
 {
     if (!Directory.Exists(Path.GetDirectoryName(User.ConnectionString.ConnectionString)))
     {
         Directory.CreateDirectory(Path.GetDirectoryName(User.ConnectionString.ConnectionString));
     }
     if (!File.Exists(User.ConnectionString.ConnectionString))
     {
         using (SqlCeEngine clientEngine = new SqlCeEngine("Data Source=" + User.ConnectionString.ConnectionString))
         {
             clientEngine.CreateDatabase();
             clientEngine.Dispose();
         }
     }
     using (SqlCeCommand cmd = MSSQLCEConn.CreateCommand(User))
     {
         cmd.CommandText = Resources.MsSqlCeDbCreateScript;
         MSSQLCEConn.ExecuteNonQuery(cmd);
     }
 }
Exemplo n.º 13
0
        public void Refresh()
        {
            this.Clear();

            using (SqlCeCommand cmd = MSSQLCEConn.CreateCommand(m_User))
            {
                cmd.CommandText = "SELECT id, username, enabled FROM UserProfiles";
                SqlCeDataReader reader = cmd.ExecuteReader();

                while (reader.Read())
                {
                    UserProfile userProfile = new UserProfile();
                    userProfile.Id       = Convert.ToInt32(reader["id"]);
                    userProfile.UserName = reader["username"].ToString();
                    userProfile.Enabled  = Convert.ToBoolean(reader["enabled"]);

                    this.Add(userProfile.Id, userProfile);
                }
            }
        }
Exemplo n.º 14
0
        public void Refresh()
        {
            this.Clear();
            using (SqlCeCommand cmd = MSSQLCEConn.CreateCommand(m_User))
            {
                cmd.CommandText = "SELECT id, clr_name, parent_id FROM TypeDefinitions";
                SqlCeDataReader reader = cmd.ExecuteReader();

                while (reader.Read())
                {
                    TypeDefinition info = new TypeDefinition();
                    info.Id      = Convert.ToInt32(reader["id"]);
                    info.ClrName = reader["clr_name"].ToString();

                    object result = reader["parent_id"];
                    info.ParentId = (result is DBNull || result == null) ? -1 : Convert.ToInt32(result);


                    this.Add(info.Id, info);
                }
            }
        }
Exemplo n.º 15
0
        /// <summary>
        /// Deletes a specific LM.
        /// </summary>
        /// <param name="css">The connection string struct.</param>
        /// <remarks>Documented by Dev02, 2008-07-28</remarks>
        /// <remarks>Documented by Dev08, 2008-12-09</remarks>
        /// <remarks>Documented by Dev08, 2008-12-09</remarks>
        public void Delete(ConnectionStringStruct css)
        {
            if (!this.HasPermission(PermissionTypes.CanModify))
            {
                throw new PermissionException();
            }
            switch (css.Typ)
            {
            case DatabaseType.PostgreSQL:
                parent.CurrentUser.CheckConnection(parent.CurrentUser.ConnectionString);
                connector.DeleteLM(css.LmId);
                break;

            case DatabaseType.MsSqlCe:
                //MSSQLCEConn.CloseAllConnections();
                MSSQLCEConn.CloseMyConnection(css.ConnectionString);            //[ML-1939] "Delete" of EDB needs very long time
                File.Delete(css.ConnectionString);
                break;

            default:
                throw new UnsupportedDatabaseTypeException(css.Typ);
            }
        }
Exemplo n.º 16
0
 private static SqlCeConnection GetConnection(string path)
 {
     return(new SqlCeConnection(MSSQLCEConn.GetFullConnectionString(path)));
 }
Exemplo n.º 17
0
        /// <summary>
        /// Checks the connection.
        /// </summary>
        /// <param name="connectionString">The connection string.</param>
        /// <remarks>Documented by Dev03, 2008-11-27</remarks>
        public void CheckConnection(ConnectionStringStruct connectionString)
        {
            if (!dbConnectionValid && connectionString.Typ != DatabaseType.Xml)
            {
                DummyUser    user = new DummyUser(connectionString);
                DbConnection con  = connectionString.Typ == DatabaseType.PostgreSQL ? PostgreSQLConn.CreateConnection(user) as DbConnection : MSSQLCEConn.GetConnection(user) as DbConnection;

                if (con.State == System.Data.ConnectionState.Open)
                {
                    dbConnectionValid = true;
                }
                else
                {
                    throw new ConnectionInvalidException();
                }

                if (connectionString.Typ == DatabaseType.PostgreSQL)
                {
                    con.Close();
                }

                DbDatabase.GetInstance(new ParentClass(new DummyUser(connectionString), this)).CheckIfDatabaseVersionSupported();
            }
        }