IncrementNameSuffixToLastName() public static method

public static IncrementNameSuffixToLastName ( string currentName, int parentNodeId ) : string
currentName string
parentNodeId int
return string
Example #1
0
        public void Execute()
        {
            if (this.Node.IsNew)
            {
                var gc = Node.Parent as GenericContent;
                if (gc != null)
                {
                    gc.AssertAllowedChildType(Node);
                }
            }

            var autoNamingAllowed = false;

            if (this.Node.AllowIncrementalNaming.HasValue)
            {
                autoNamingAllowed = this.Node.AllowIncrementalNaming.Value;
            }
            else
            {
                autoNamingAllowed = this.Node.Id == 0 && ContentType.GetByName(this.Node.NodeType.Name).AllowIncrementalNaming;
            }

            while (true)
            {
                try
                {
                    Node.Save(this);
                    break;
                }
                catch (Storage.Data.NodeAlreadyExistsException)
                {
                    if (!autoNamingAllowed)
                    {
                        throw;
                    }

                    this.Node.Name = ContentNamingHelper.IncrementNameSuffixToLastName(Node.Name, Node.ParentId);
                }
            }
        }
Example #2
0
        public static void Restore(TrashBag trashBag, string targetPath, bool addNewName)
        {
            if (trashBag == null || string.IsNullOrEmpty(targetPath))
            {
                throw new RestoreException(RestoreResultType.Nonedefined);
            }

            targetPath = targetPath.TrimEnd(new [] { '/' });

            var node = trashBag.DeletedContent;

            if (node == null)
            {
                throw new InvalidOperationException("TrashBag is empty");
            }

            var targetContentPath = RepositoryPath.Combine(targetPath, node.Name);
            var targetParent      = Node.Load <GenericContent>(targetPath);

            if (targetParent == null)
            {
                throw new RestoreException(RestoreResultType.NoParent,
                                           RepositoryPath.GetParentPath(targetPath));
            }

            //assert permissions
            if (!targetParent.Security.HasPermission(PermissionType.Open))
            {
                throw new RestoreException(RestoreResultType.PermissionError, targetContentPath);
            }

            //target type check: ContentTypes field
            AssertRestoreContentType(targetParent, node);

            if (Node.Exists(targetContentPath))
            {
                var newName = ContentNamingHelper.IncrementNameSuffixToLastName(node.Name, targetParent.Id);
                targetContentPath = RepositoryPath.Combine(targetPath, newName);

                if (addNewName)
                {
                    try
                    {
                        //there is no other way right now (rename and move cannot be done at the same time)
                        node.Name = newName;
                        node.Save();
                    }
                    catch (SenseNetSecurityException ex)
                    {
                        Logger.WriteException(ex);
                        throw new RestoreException(RestoreResultType.PermissionError,
                                                   targetContentPath, ex);
                    }
                    catch (Exception ex)
                    {
                        Logger.WriteException(ex);
                        throw new RestoreException(RestoreResultType.UnknownError,
                                                   targetContentPath, ex);
                    }
                }
                else
                {
                    throw new RestoreException(RestoreResultType.ExistingName,
                                               targetContentPath);
                }
            }

            var originalUser = User.Current;

            try
            {
                node.MoveTo(targetParent);

                AccessProvider.Current.SetCurrentUser(User.Administrator);

                trashBag.KeepUntil = DateTime.Today.AddDays(-1);
                trashBag.ForceDelete();
            }
            catch (SenseNetSecurityException ex)
            {
                Logger.WriteException(ex);
                throw new RestoreException(RestoreResultType.PermissionError,
                                           targetContentPath, ex);
            }
            catch (Exception ex)
            {
                Logger.WriteException(ex);
                throw new RestoreException(RestoreResultType.UnknownError,
                                           targetContentPath, ex);
            }
            finally
            {
                AccessProvider.Current.SetCurrentUser(originalUser);
            }
        }