protected override NodeBase SaveContent(NodeBase node, NodeContent content)
        {
            if (!node.Exists())
            {
                return(node);
            }

            FileInfo file = null;

            try
            {
                using (var scope = _factory.CreateScope())
                {
                    var callPath = $"{MethodBase.GetCurrentMethod().DeclaringType.Name}.{MethodBase.GetCurrentMethod().Name}";

                    if (node.NodeType == NodeType.File)
                    {
                        var conf = scope.ServiceProvider.GetRequiredService <IConfiguration>();
                        var uow  = scope.ServiceProvider.GetRequiredService <IUnitOfWork>();

                        var fileEntity = CompositeFileSystemHelper.FilePathToEntity(uow, _userEntity, node.Path.StringPath);

                        file = new FileInfo(conf["Storage:UnstructuredDataPath"]
                                            + Path.DirectorySeparatorChar + fileEntity.RealPath
                                            + Path.DirectorySeparatorChar + fileEntity.RealFileName);

                        fileEntity = CompositeFileSystemHelper.SaveFileStream(conf, content.GetStream(), fileEntity);

                        uow.UserFiles.Update(fileEntity);
                        uow.Commit();

                        Log.Information($"'{callPath}' '{_userEntity.IdentityAlias}' file '{node.Path}' to '{file.FullName}'");

                        return(node);
                    }
                    else
                    {
                        throw new NotImplementedException();
                    }
                }
            }
            catch (Exception ex) when(ex is DbUpdateException || ex is DbUpdateConcurrencyException)
            {
                if (file.Exists)
                {
                    file.Delete();
                }

                Log.Error(ex.ToString());
                throw;
            }
            catch (Exception ex)
            {
                Log.Error(ex.ToString());
                throw;
            }
        }
Example #2
0
        protected override NodeBase SaveContent(NodeBase node, NodeContent content)
        {
            var callPath = $"{MethodBase.GetCurrentMethod().DeclaringType.Name}.{MethodBase.GetCurrentMethod().Name}";

            DirectoryInfo folder = null;
            FileInfo      file   = null;

            try
            {
                if (!node.Exists())
                {
                    return(node);
                }

                if (node.NodeType == NodeType.File)
                {
                    WindowsIdentity.RunImpersonated(_userToken, () =>
                    {
                        folder = SmbFileSystemHelper.FolderPathToCIFS(_userMount + node.Parent.Path.StringPath);

                        if (!folder.Exists)
                        {
                            folder.Create();
                        }

                        file = SmbFileSystemHelper.FilePathToCIFS(_userMount + node.Path.StringPath);

                        using (var fs = new FileStream(file.FullName, FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite))
                            content.GetStream().CopyTo(fs);

                        Log.Information($"'{callPath}' '{_userEntity.IdentityAlias}' file '{node.Path}' to '{file.FullName}'" +
                                        $" run as '{WindowsIdentity.GetCurrent().Name}'");
                    });
                }
                else
                {
                    throw new NotImplementedException();
                }

                return(node);
            }
            catch (Exception ex)
            {
                Log.Error(ex.ToString());
                throw;
            }
        }
        protected override NodeBase SaveContent(NodeBase node, NodeContent content)
        {
            if (!node.Exists())
            {
                return(node);
            }

            var callPath = $"{MethodBase.GetCurrentMethod().DeclaringType.Name}.{MethodBase.GetCurrentMethod().Name}";

            var newStream = new MemoryStream();

            content.GetStream().CopyTo(newStream);
            newStream.Position = 0;

            _store[node].Content = newStream;

            Log.Information($"'{callPath}' '{_userEntity.IdentityAlias}' file '{node.Path}'");

            return(node);
        }