Пример #1
0
        bool Save(bool prompt)
        {
            UserObject uo2;

            if (!IsValidCalcField())
            {
                return(false);
            }
            if (!GetCalcFieldForm())
            {
                return(false);
            }
            if (prompt)
            {
                uo2 = UserObjectSaveDialog.Show("Save Calculated Field Definition", UoIn);
                if (uo2 == null)
                {
                    return(false);
                }
            }
            else
            {
                uo2 = UoIn.Clone();
            }

            if (!UserObjectUtil.UserHasWriteAccess(uo2))
            {             // is the user authorized to save this?
                MessageBoxMx.ShowError("You are not authorized to save this calculated field");
                return(false);
            }

            SessionManager.DisplayStatusMessage("Saving calculated field...");

            string content = CalcField.Serialize();

            uo2.Content = content;

            //need the name of the folder to which the object will be saved
            MetaTreeNode targetFolder = UserObjectTree.GetValidUserObjectTypeFolder(uo2);

            if (targetFolder == null)
            {
                MessageBoxMx.ShowError("Failed to save your calculated field.");
                return(false);
            }

            UserObjectDao.Write(uo2);

            string tName = "CALCFIELD_" + uo2.Id.ToString();

            QbUtil.UpdateMetaTableCollection(tName);
            MainMenuControl.UpdateMruList(tName);

            string title = "Edit Calculated Field - " + uo2.Name;

            Text = title;
            UoIn = uo2.Clone();             // now becomes input object
            SessionManager.DisplayStatusMessage("");
            return(true);
        }
Пример #2
0
        void Setup(UserObject uo)
        {
            Text = "Permissions for " + uo.Name;

            Uo = uo;

            if (UserObjectUtil.UserHasWriteAccess(uo))
            {
                Editable = true;
                PermissionsList.Editable = true;
                MakePublic.Enabled       = MakePrivate.Enabled = AdvancedButton.Enabled = true;
            }

            else
            {
                Editable = false;
                PermissionsList.Editable = false;
                MakePublic.Enabled       = MakePrivate.Enabled = AdvancedButton.Enabled = false;
            }

            AccessControlList acl = AccessControlList.Deserialize(uo);

            PermissionsList.Setup(acl);
            return;
        }
Пример #3
0
/// <summary>
/// Change owner
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>

        private void ChangeOwnerMenuItem_Click(object sender, EventArgs e)
        {
            {
                List <string> users    = SecurityUtil.GetAllUsers();
                string        prompt   = "Enter the user name of the person to transfer ownership of " + Lex.AddDoubleQuotes(Uo.Name) + " to:";
                string        newOwner = InputBoxMx.Show(prompt, "Change Owner", "", users, -1, -1);
                if (Lex.IsNullOrEmpty(newOwner))
                {
                    return;
                }

                string newUserName = SecurityUtil.GetInternalUserName(newOwner);
                if (Lex.IsNullOrEmpty(newUserName))
                {
                    return;
                }

                string result = UserObjectUtil.ChangeOwner(Uo.Id, newUserName);
                if (!Lex.IsNullOrEmpty(result))
                {
                    MessageBoxMx.Show(result);
                    DialogResult = DialogResult.Cancel;                     // close the dialog
                }
                return;
            }
        }
Пример #4
0
        /// <summary>
        /// See if current user can modify supplied annotation table or calc field
        /// </summary>
        /// <param name="mt"></param>
        /// <returns></returns>

        public static bool CanModifyTable(
            MetaTable mt)
        {
            if (mt.MetaBrokerType == MetaBrokerType.Unknown)
            {
                return(true);                                                         // Allow if no broker type (i.e. Transient Conditional Formatting control, etc)
            }
            else if (mt.MetaBrokerType == MetaBrokerType.Annotation || mt.MetaBrokerType == MetaBrokerType.CalcField)
            {
                if (mt.Code == null || mt.Code == "" || mt.Code == "0")
                {
                    return(true);                                                               // assume ok if new object with no code assigned
                }
                return(UserObjectUtil.UserHasWriteAccess(SS.I.UserName, Int32.Parse(mt.Code))); // the code for the table is the object id
            }

            else if (mt.IsUserDatabaseStructureTable)
            {
                if (mt.Code == null || mt.Code == "" || mt.Code == "0")
                {
                    return(true);                    // assume ok if new object with no code assigned
                }
                long databaseId = Int64.Parse(mt.Code);

                UserCmpndDbDao udbs = new UserCmpndDbDao();
                return(udbs.CanModifyDatabase(databaseId, SS.I.UserName));
            }

            else
            {
                return(false);
            }
        }
Пример #5
0
        /// <summary>
        /// See if the named list exists
        /// </summary>
        /// <param name="name"></param>
        /// <returns></returns>

        public static bool Exists(
            string name)
        {
            UserObject uo = UserObjectUtil.ParseInternalUserObjectName(name);

            uo.Type = UserObjectType.CnList;
            uo      = UserObjectDao.ReadHeader(uo);
            return(uo != null);
        }
Пример #6
0
/// <summary>
/// Save the SpotfireLink UserObject
/// </summary>
/// <param name="prompt"></param>
/// <returns></returns>

        bool Save(bool prompt)
        {
            UserObject uo2;

            if (!IsValidSpotfireLink())
            {
                return(false);
            }
            if (!GetSpotfireLinkForm())
            {
                return(false);
            }
            if (prompt)
            {
                uo2 = UserObjectSaveDialog.Show("Save Spotfire link Definition", UoIn);
                if (uo2 == null)
                {
                    return(false);
                }
            }

            else
            {
                uo2 = UoIn.Clone();
            }

            uo2.Content = SpotfireViewProps.Serialize();

            if (!UserObjectUtil.UserHasWriteAccess(uo2))
            {             // is the user authorized to save this?
                MessageBoxMx.ShowError("You are not authorized to save this Spotfire link");
                return(false);
            }

            SessionManager.DisplayStatusMessage("Saving Spotfire link...");

            //need the name of the folder to which the object will be saved
            MetaTreeNode targetFolder = UserObjectTree.GetValidUserObjectTypeFolder(uo2);

            if (targetFolder == null)
            {
                MessageBoxMx.ShowError("Failed to save your Spotfire link.");
                return(false);
            }

            UserObjectDao.Write(uo2);

            MainMenuControl.UpdateMruList(uo2.InternalName);

            string title = "Edit Spotfire Link - " + uo2.Name;

            Text = title;
            UoIn = uo2.Clone();             // now becomes input object
            SessionManager.DisplayStatusMessage("");
            return(true);
        }
Пример #7
0
        /// <summary>
        /// Set Enable for a Paste ToolStripMenuItem based on whether there is a UserObject in the clipboard
        /// </summary>
        /// <param name="mi"></param>

        void SetPasteEnable(ToolStripMenuItem mi)
        {
            bool enable = false;

            try
            {
                string txt = Clipboard.GetText();
                //if (UserObject.Deserialize(txt) != null) enable = true;
                UserObject[] userobjects = UserObjectUtil.Deserialize(txt);
                if (userobjects != null)
                {
                    enable = true;
                }
            }
            catch (Exception ex) { }

            mi.Enabled = enable;
            return;
        }
Пример #8
0
        /// <summary>
        /// See if the current user can modify the supplied object
        /// </summary>
        /// <param name="objectId"></param>
        /// <returns></returns>

        public static bool UserHasWriteAccess(
            string userName,
            int objectId)
        {
            if (objectId <= 0)
            {
                return(true);                           // new unsaved object
            }
            if (objectId == LastUserHasWriteAccessId)
            {
                return(LastUserHasWriteAccessResult);
            }

            UserObject uo = UserObjectDao.ReadHeader(objectId);

            LastUserHasWriteAccessId     = objectId;
            LastUserHasWriteAccessResult = UserObjectUtil.UserHasWriteAccess(uo);

            return(LastUserHasWriteAccessResult);
        }
Пример #9
0
        /// <summary>
        /// Read a compound id list given an internal list name (e.g. FOLDER_123.name or LIST_1234)
        /// </summary>
        /// <param name="name"></param>
        /// <param name="mt"></param>
        /// <returns></returns>

        public static CidList Read(
            string internalName,
            MetaTable mt,
            bool allowLocalRead)
        {
            UserObject uo, uo2;
            string     fileName, cn;
            int        i1;

            uo = UserObjectUtil.ParseInternalUserObjectName(internalName, UserObjectType.CnList);
            if (uo == null)
            {
                return(null);
            }

            if (allowLocalRead && UserObject.IsCurrentObjectInternalName(internalName))             // get from the current query
            {
                return(ReadCurrentListLocal());
            }

            uo2 = UserObjectDao.Read(uo);             // get from the server side
            if (uo2 == null)
            {
                MessageBoxMx.ShowError(
                    "Unable to find list: " + internalName + "\r\n\r\n" +
                    CommandExec.GetUserObjectReadAccessErrorMessage(uo.Id, "list"));
                return(null);
            }

            CidList cnList = CidList.Deserialize(uo2, mt);

            if (UserObject.IsCurrentObjectInternalName(internalName))             // if current list store keys with query
            {
                SessionManager.CurrentResultKeys = cnList.ToStringList();
            }

            return(cnList);
        }
Пример #10
0
        /// <summary>
        /// Create an annotation table from a DataTable
        /// </summary>
        /// <param name="fullyQualifiedName">Fully qualified name to assign to table</param>
        /// <param name="dataTable">DataTable containing table definition & data</param>
        /// <param name="showProgress">Display dialog box showing progress of creation</param>
        /// <returns>Internal name assigned to annotation table (ANNOTATION_12345)</returns>

        public static MetaTable CreateAnnotationTable(
            string fullyQualifiedName,
            DataTable dataTable,
            bool showProgress)
        {
            List <AnnotationVo> voList = new List <AnnotationVo>();
            AnnotationVo        avo;

            if (dataTable == null)
            {
                DebugMx.ArgException("DataTable is null");
            }
            if (dataTable.Columns.Count == 0)
            {
                DebugMx.ArgException("No DataColumns are defined");
            }
            if (dataTable.Columns[0].DataType != typeof(CompoundId))
            {
                DebugMx.ArgException("The first column must be of type CompoundId");
            }

            if (showProgress)
            {
                Progress.Show("Creating annotation table...");
            }

            AnnotationDao aDao = new AnnotationDao();
            UserObject    auo  = UserObjectUtil.ParseInternalUserObjectName(fullyQualifiedName);

            auo.Type = UserObjectType.Annotation;
            UserObjectTree.GetValidUserObjectTypeFolder(auo);
            UserObject auo2  = UserObjectDao.Read(auo);            // see if there already
            MetaTable  oldMt = null;

            if (auo2 == null)                       // get new identifier
            {
                auo.Id = UserObjectDao.GetNextId(); // id to store table under
            }
            else                                    // reuse identifier
            {
                auo.Id = auo2.Id;                   // copy it over
                aDao.DeleteTable(auo.Id);           // delete any existing data
                string oldMtName = "ANNOTATION_" + auo2.Id;
                oldMt = MetaTableCollection.Get(oldMtName);
            }

            MetaTable mt = new MetaTable();

            mt.MetaBrokerType = MetaBrokerType.Annotation;
            mt.Name           = "ANNOTATION_" + auo.Id; // name table by uo
            mt.Label          = auo.Name;
            mt.Code           = auo.Id.ToString();      // code for the metatable
            int mtCode = auo.Id;

            if (dataTable.ExtendedProperties.ContainsKey("ParentTableName"))
            {
                mt.Parent = MetaTableCollection.Get((string)dataTable.ExtendedProperties["ParentTableName"]);
            }

            foreach (DataColumn dc in dataTable.Columns)
            {
                MetaColumn mc = new MetaColumn();
                mc.MetaTable = mt;
                mc.Name      = dc.ColumnName;
                MetaColumn oldMc = null;
                if (oldMt != null)
                {
                    oldMc = oldMt.GetMetaColumnByName(mc.Name);              // see if column name exists
                }
                if (oldMc != null && oldMc.ResultCode != "")                 // use any existing code
                {
                    mc.ResultCode = oldMc.ResultCode;
                }
                else
                {
                    mc.ResultCode = aDao.GetNextIdLong().ToString();
                }

                if (dc.Caption != null)
                {
                    mc.Label = dc.Caption;
                }
                else
                {
                    mc.Label = mc.Name;
                }
                if (dc.DataType == typeof(CompoundId))
                {
                    mc.DataType = MetaColumnType.CompoundId;
                    if (dc.ExtendedProperties.ContainsKey("StorageType") && dc.ExtendedProperties["StorageType"] is MetaColumnType &&
                        ((MetaColumnType)dc.ExtendedProperties["StorageType"]) == MetaColumnType.String)
                    {
                        mc.ColumnMap = "EXT_CMPND_ID_TXT";                         // text column
                    }
                    else
                    {
                        mc.ColumnMap = "EXT_CMPND_ID_NBR";                      // numeric column otherwise
                    }
                }
                else if (dc.DataType == typeof(int) || dc.DataType == typeof(Int16) || dc.DataType == typeof(Int32))
                {
                    mc.DataType = MetaColumnType.Integer;
                }
                else if (dc.DataType == typeof(float) || dc.DataType == typeof(double))
                {
                    mc.DataType = MetaColumnType.Number;
                }
                else if (dc.DataType == typeof(QualifiedNumber))
                {
                    mc.DataType = MetaColumnType.QualifiedNo;
                }
                else if (dc.DataType == typeof(string))
                {
                    mc.DataType = MetaColumnType.String;
                }
                else if (dc.DataType == typeof(DateTime))
                {
                    mc.DataType = MetaColumnType.Date;
                }
                else if (dc.DataType == typeof(MoleculeMx))
                {
                    mc.DataType = MetaColumnType.Structure;
                }
                else
                {
                    throw new Exception("Invalid data type " + dc.DataType.ToString());
                }

                if (dc.ExtendedProperties.ContainsKey("DisplayLevel"))
                {
                    mc.InitialSelection = (ColumnSelectionEnum)dc.ExtendedProperties["DisplayLevel"];
                }
                if (dc.ExtendedProperties.ContainsKey("DisplayWidth"))
                {
                    mc.Width = (float)dc.ExtendedProperties["DisplayWidth"];
                }
                if (dc.ExtendedProperties.ContainsKey("DisplayFormat"))
                {
                    mc.Format = (ColumnFormatEnum)dc.ExtendedProperties["DisplayFormat"];
                }
                if (dc.ExtendedProperties.ContainsKey("Decimals"))
                {
                    mc.Decimals = (int)dc.ExtendedProperties["Decimals"];
                }

                mt.MetaColumns.Add(mc);
            }

            ToolHelper.CreateAnnotationTable(mt, auo);

            aDao.BeginTransaction();             // insert all data in single transaction

            if (showProgress)
            {
                Progress.Show("Writing data to annotation table...");
            }
            int t1         = TimeOfDay.Milliseconds();
            int writeCount = 0;

            foreach (DataRow dr in dataTable.Rows)
            {
                if (dr.IsNull(0))
                {
                    continue;                               // shouldn't happen
                }
                string key = dr[0].ToString();
                key = CompoundId.NormalizeForDatabase(key, mt.Root);
                long rslt_grp_id = aDao.GetNextIdLong();

                for (int ci = 1; ci < dataTable.Columns.Count; ci++)                 // do columns after key
                {
                    if (dr.IsNull(ci))
                    {
                        continue;
                    }
                    DataColumn dc     = dataTable.Columns[ci];
                    MetaColumn mc     = mt.MetaColumns[ci];
                    int        mcCode = Int32.Parse(mc.ResultCode);
                    avo             = new AnnotationVo();
                    avo.rslt_grp_id = rslt_grp_id;                     // keep row together

                    if (dc.DataType == typeof(CompoundId))             // shouldn't happen since key processed already
                    {
                        avo.rslt_val_txt = dr[ci].ToString();
                    }

                    else if (dc.DataType == typeof(int) || dc.DataType == typeof(Int16) || dc.DataType == typeof(Int32) ||
                             dc.DataType == typeof(float) || dc.DataType == typeof(double))
                    {
                        avo.rslt_val_nbr = (double)dr[ci];
                    }

                    else if (dc.DataType == typeof(QualifiedNumber))
                    {
                        QualifiedNumber qn = (QualifiedNumber)dr[ci];
                        avo.rslt_val_nbr      = qn.NumberValue;
                        avo.rslt_val_prfx_txt = qn.Qualifier;
                        avo.rslt_val_txt      = qn.TextValue;
                        avo.dc_lnk            = qn.Hyperlink;
                    }

                    else if (dc.DataType == typeof(string))
                    {
                        avo.rslt_val_txt = dr[ci].ToString();
                    }

                    else if (dc.DataType == typeof(DateTime))
                    {
                        avo.rslt_val_dt = (DateTime)dr[ci];
                    }

                    else if (dc.DataType == typeof(MoleculeMx))
                    {
                        avo.rslt_val_txt = dr[ci].ToString();
                    }

                    AddAnnotationVoToList(avo, key, mtCode, mcCode, voList);
                }

                writeCount++;

                if (Progress.CancelRequested)                 // check for cancel
                {
                    aDao.Commit();
                    aDao.Insert(voList);
                    voList.Clear();
                    aDao.Commit();
                    aDao.Dispose();
                    if (showProgress)
                    {
                        Progress.Hide();
                    }
                    MessageBoxMx.ShowError("Writing of annotation table cancelled.");
                    return(null);
                }

                int t2 = TimeOfDay.Milliseconds();
                if (showProgress && t2 - t1 >= 1000)
                {
                    t1 = t2;
                    Progress.Show("Writing data to annotation table " + writeCount.ToString() +
                                  " of " + dataTable.Rows.Count.ToString() + " ...");
                    aDao.Insert(voList);
                    voList.Clear();
                    aDao.Commit();
                }
            }

            aDao.Insert(voList);
            voList.Clear();
            aDao.Commit();
            aDao.Dispose();

            if (showProgress)
            {
                Progress.Hide();
            }
            return(mt);            // return metatable name
        }
Пример #11
0
/// <summary>
/// Right-click commands on objects in a tree
/// </summary>
/// <param name="command">The command to process</param>
        /// <param name="mtn">MetaTreeNode</param>
        /// <param name="uo">Any associated user object</param>
        /// <param name="ctc">ContentsTreeControl</param>
/// <returns></returns>

        public static bool ProcessCommonRightClickObjectMenuCommands(
            string command,
            MetaTreeNode mtn,
            UserObject[] uoArray,
            ContentsTreeControl ctc)
        {
            UserObject uo2;
            string     txt;
            UserObject uo = null;

            if (uoArray != null && uoArray.Length == 1)
            {
                uo = uoArray[0];
            }

            //if (mtn == null)
            //{
            //	MessageBoxMx.ShowError("Operation is not allowed for this Database Contents node.");
            //	return true;
            //}

            if (Lex.Eq(command, "Cut"))
            {
                CopyCutDelete(command, uoArray, ctc, true, true);
            }

            else if (Lex.Eq(command, "Copy"))
            {
                CopyCutDelete(command, uoArray, ctc, true, false);
            }

            else if (Lex.Eq(command, "Paste"))
            {
                try
                {
                    txt = Clipboard.GetText();
                    //uo2 = UserObject.Deserialize(txt);
                    uoArray = Deserialize(txt);
                    if (uoArray == null)
                    {
                        throw new Exception("Not a UserObject");
                    }
                    //if (uo2 == null) throw new Exception("Not a UserObject");
                }
                catch (Exception ex)
                {
                    MessageBoxMx.ShowError("The clipboard does not contain a recognized user objects");
                    return(true);
                }

                foreach (var userObject in uoArray)
                {
                    Progress.Show("Pasting " + userObject.Name + "...", UmlautMobius.String, false);

                    Permissions.UpdateAclForNewOwner(userObject, userObject.Owner, SS.I.UserName); // fixup the ACL for the new owner
                    userObject.Owner        = SS.I.UserName;
                    userObject.ParentFolder = mtn.Name;
                    mtn = UserObjectTree.GetValidUserObjectTypeFolder(userObject);

                    for (int ci = 0; ; ci++) // find a name that's not used
                    {
                        UserObject uo3 = UserObjectDao.ReadHeader(userObject);
                        if (uo3 == null)
                        {
                            break;
                        }

                        if (ci == 0)
                        {
                            userObject.Name = "Copy of " + userObject.Name;
                        }
                        else if (ci == 1)
                        {
                            userObject.Name = Lex.Replace(userObject.Name, "Copy of ", "Copy (2) of ");
                        }
                        else
                        {
                            userObject.Name = Lex.Replace(userObject.Name, "Copy (" + ci + ") of ", "Copy (" + (ci + 1) + ") of ");
                        }
                    }

                    UserObject userObjectFinal = null;
                    if (UserObjectDao.ReadHeader(userObject.Id) != null) // create a deep clone if orignal object exists
                    {
                        userObjectFinal = DeepClone(userObject);
                    }

                    if (userObjectFinal == null)
                    {
                        userObjectFinal = userObject;
                    }

                    UserObjectDao.Write(userObjectFinal, userObjectFinal.Id); // write using the current id

                    Progress.Hide();
                }

                //if (ctc != null) // need to update form directly?
                //  UserObjectTree.RefreshSubtreeInTreeControl(uo2, ctc);
            }

            else if (Lex.Eq(command, "Delete"))
            {
                CopyCutDelete(command, uoArray, ctc, false, true);
            }

            else if (Lex.Eq(command, "Rename"))
            {
                if (!UserHasWriteAccess(uo))
                {
                    MessageBoxMx.ShowError("You are not authorized to rename " + uo.Name);
                    return(true);
                }

                string newName = InputBoxMx.Show("Enter the new name for " + uo.Name,
                                                 "Rename", uo.Name);

                if (newName == null || newName == "" || newName == uo.Name)
                {
                    return(true);
                }

                if (!IsValidUserObjectName(newName))
                {
                    MessageBoxMx.ShowError("The name " + newName + " is not valid.");
                    return(true);
                }

                uo2      = uo.Clone();
                uo2.Name = newName;
                uo2.Id   = 0;               // clear Id so not looked up by id

                if (!Lex.Eq(newName, uo.Name) && UserObjectDao.ReadHeader(uo2) != null)
                {
                    MessageBoxMx.ShowError(newName + " already exists.");
                    return(true);
                }

                uo2.Id = uo.Id;
                UserObjectDao.UpdateHeader(uo2);

                if (ctc != null)
                {
                    UserObjectTree.UpdateObjectInTreeControl(uo, uo2, ctc);
                }
            }

            else if (Lex.Eq(command, "MakePublic") ||
                     Lex.Eq(command, "MakePrivate"))
            {
                UserObjectAccess newAccess;
                MetaTreeNode     objFolder;

                if (!UserHasWriteAccess(uo))
                {
                    MessageBoxMx.ShowError("You are not authorized to make " + uo.Name +
                                           ((Lex.Eq(command, "MakePublic")) ? " public" : " private"));
                    return(true);
                }

                if (Lex.Eq(command, "MakePublic"))
                {
                    if (uo.ParentFolder == "DEFAULT_FOLDER")
                    {
                        MessageBoxMx.ShowError("Items in the Default Folder cannot be made public");
                        return(true);
                    }
                    else
                    {
                        //check the folder id parentage to ensure that the current folder isn't a subfolder of the default folder
                        if (UserObjectTree.FolderNodes.ContainsKey(uo.ParentFolder))
                        {
                            objFolder = UserObjectTree.FolderNodes[uo.ParentFolder];
                            while (objFolder != null)
                            {
                                if (objFolder.Target == "DEFAULT_FOLDER")
                                {
                                    MessageBoxMx.ShowError("Items in the Default Folder cannot be made public");
                                    return(true);
                                }
                                objFolder = objFolder.Parent;
                            }
                        }
                        else
                        {
                            throw new Exception("Failed to recognize the folder that this object is in!");
                        }
                    }

                    newAccess = UserObjectAccess.Public;
                }
                else
                {
                    //user folders cannot be made private if they contain public children
                    if (uo.Type == UserObjectType.Folder)
                    {
                        objFolder = UserObjectTree.BuildNode(uo);
                        if (UserObjectTree.FolderNodes.ContainsKey(objFolder.Target))
                        {
                            objFolder = UserObjectTree.FolderNodes[objFolder.Target];
                            for (int i = 0; i < objFolder.Nodes.Count; i++)
                            {
                                MetaTreeNode currentChild = (MetaTreeNode)objFolder.Nodes[i];
                            }
                        }
                    }

                    newAccess = UserObjectAccess.Private;
                }

                uo2 = UserObjectDao.Read(uo);
                if (uo2 == null)
                {
                    return(true);
                }
                if (uo2.AccessLevel == newAccess)
                {
                    return(true);                                              // no change
                }
                uo2.AccessLevel = newAccess;
                UserObjectDao.UpdateHeader(uo2);

                if (ctc != null)                 // need to update form directly?
                {
                    UserObjectTree.RefreshSubtreeInTreeControl(uo2, ctc);
                }

                return(true);
            }

            else if (Lex.Eq(command, "ChangeOwner"))
            {
                string newOwner = InputBoxMx.Show("Enter the user name of the person to transfer ownership of " + Lex.AddDoubleQuotes(uo.Name) + " to:",
                                                  "Change Owner", "");

                if (Lex.IsNullOrEmpty(newOwner))
                {
                    return(true);
                }

                string result = UserObjectUtil.ChangeOwner(uo.Id, newOwner);
                if (!Lex.IsNullOrEmpty(result))
                {
                    MessageBoxMx.Show(result);
                }
                return(true);
            }

            else if (Lex.Eq(command, "Permissions"))             // set object permissions
            {
                PermissionsDialog.Show(uo);
                return(true);
            }

            else if (Lex.Eq(command, "ViewSource"))
            {
                uo = UserObjectDao.Read(uo);
                if (uo == null)
                {
                    return(true);
                }

                string ext = ".txt";                 // default extension
                if (uo.Type == UserObjectType.Query ||
                    uo.Type == UserObjectType.Annotation)
                {
                    ext = ".xml";
                }
                string       cFile = ClientDirs.TempDir + @"\Source" + ext;
                StreamWriter sw    = new StreamWriter(cFile);
                sw.Write(uo.Content);
                sw.Close();

                SystemUtil.StartProcess(cFile);                 // show it
            }

            else
            {
                return(false);       // command not recognized
            }
            return(true);            // command recognized and processed
        }
Пример #12
0
 private void ViewSourceMenuItem_Click(object sender, EventArgs e)
 {
     UserObjectUtil.ProcessCommonRightClickObjectMenuCommands("ViewSource", CurrentContentsMetaTreeNode, ContentsTreeControl);
 }
Пример #13
0
/// <summary>
/// Save/SaveAs the list
/// </summary>
/// <param name="saveAs">SaveAs under another list name</param>
/// <param name="saveAsTempList">Save as a temp list</param>
/// <param name="tempListName">Temp list name to save under, prompt if null</param>
/// <returns></returns>

        bool Save(
            bool saveAs,
            bool saveAsTempList,
            string tempListName)
        {
            if (!ValidateList())
            {
                return(false);                             // Validate the list if requested
            }
// Get list name if needed & check that user can modify it

            if (saveAs || CidList.UserObject.Id == 0)
            {
                CidList.UserObject.Id = 0;                 // assign new id
                if (saveAsTempList)
                {
                    if (tempListName == null)                     // prompt for name
                    {
                        tempListName = CidListCommand.PromptForNewTempListName();
                        if (tempListName == null)
                        {
                            return(false);
                        }
                    }
                    CidList.UserObject = new UserObject(UserObjectType.CnList);
                    CidList.UserObject.ParentFolder = UserObject.TempFolderName;
                    CidList.UserObject.Name         = tempListName;
                    CidList.UserObject.Owner        = SS.I.UserName;
                }

                else                 // save as permanent list
                {
                    UserObject existingUo = CidList.UserObject;
                    if (CidList.UserObject.Id == 0)
                    {
                        existingUo = new UserObject(UserObjectType.CnList);
                    }
                    UserObject listUo = UserObjectSaveDialog.Show("Save As", existingUo);
                    if (listUo == null)
                    {
                        return(false);
                    }
                    CidList.UserObject = listUo;
                }
            }

            if (!UserObjectUtil.UserHasWriteAccess(CidList.UserObject))
            {             // is the user authorized to save this list?
                MessageBoxMx.ShowError("You are not authorized to save this list");
                return(false);
            }

// Write out the list

            DisplayStatusMsg("Saving list...");

            if (CidList.UserObject.HasDefinedParentFolder)
            {
                MetaTreeNode targetFolder = UserObjectTree.GetValidUserObjectTypeFolder(CidList.UserObject);
                if (targetFolder == null)
                {                 // shouldn't happen
                    MessageBoxMx.ShowError("The list could not be saved because the folder it was in no longer exists.  Please try SaveAs instead.");
                    return(false);
                }
            }

            GetNormalizedListFromControl(CidList);

            if (!CidList.UserObject.IsCurrentObject)             // normal list?
            {
                CidListCommand.Write(CidList);
            }

            else                                       // special processing for current list
            {
                SessionManager.LockResultsKeys = true; // avoid possible overwrite of ResultsKeys if in single step query
                int           rc            = CidListCommand.Write(CidList);
                List <string> curListString = CidListCommand.ReadCurrentListLocal().ToStringList();
                SessionManager.CurrentResultKeys = curListString;
                SessionManager.DisplayCurrentCount();
                SessionManager.LockResultsKeys = false;
            }

            //string cFile = SS.I.ClientDefaultDir + @"\Previous.lst"
            //if (UIMisc.CanWriteFileToDefaultDir(cFile))
            //{
            //  StreamWriter sw = new StreamWriter(cFile); // save copy to disk
            //  sw.Write(CidList.UserObject.Content);
            //  sw.Close();
            //}

            int cncnt = CidList.Count;

            DisplayStatusMsg("List saved");

            Before = CidListCtl.Text;
            string tok = UserObjectUtil.GetName(ListName);

            Text = "Edit List - [" + CidList.UserObject.Name + "]";
            return(true);
        }
Пример #14
0
/// <summary>
/// Setup for edit
/// </summary>
/// <param name="inList"></param>
/// <param name="rootTable"></param>
/// <returns></returns>

        bool Setup(
            CidList inList,
            MetaTable rootTable)
        {
            string formattedCid, label, txt;

            RootTable = rootTable;

            InListName = inList.UserObject.Name;
            ListName   = InListName;

            CidList  = inList.Clone();        // make copy of list to edit
            CidCount = InitialCount = CidList.Count;
            if (CidCount > 32000)             // too big to edit?
            {
                txt =
                    "The list contains " + CidList.Count.ToString() + " compound numbers which\n" +
                    "exceeds the maximum of 32,000 that can be directly edited.\n" +
                    " Do you want to clear the list and start a new list?";

                DialogResult dr = MessageBoxMx.Show(txt, "List Too Large to Edit", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Exclamation);

                if (dr != DialogResult.Yes)
                {
                    return(false);
                }

                CidList            = new CidList();
                CidList.UserObject =                         // set name properly
                                     UserObjectUtil.ParseInternalUserObjectName(InListName, UserObjectType.CnList);
            }

            Text = "Edit List - [" + CidList.UserObject.Name + "]";

            Before = FormatList();             // convert & save initial list

            if (rootTable != null)
            {
                label = rootTable.KeyMetaColumn.Label;
            }
            else
            {
                label = "Compound Id";
            }

            ListLabel.Text = " " + label + " - (Enter one number per line) ";
            RNLabel.Text   = label + ":";

            MolCtl.ClearMolecule();             // clear any structure
            CidCtl.Text = HeavyAtoms.Text = Weight.Text = Formula.Text = "";

            CidListCtl.Text = Before;             // put text in editor

            DisplayStatusMsg("");

            if (SS.I.AllowGroupingBySalts)
            {
                SaltsMenu.Enabled = true;
            }
            else
            {
                SaltsMenu.Enabled = false;
            }

            return(true);
        }