Пример #1
0
        public FichierEntete Add(IFormFile file, Guid documentId, Guid userId)
        {
            if (file.Length > 0)
            {
                var fileName      = Path.GetFileName(file.FileName);
                var fileExtension = Path.GetExtension(fileName);
                var newFileName   = String.Concat(fileName, fileExtension);
                var protector     = _protectorProvider.CreateProtector("LazyDocs.Fichier", userId.ToString());

                var fichier = new EntityFile()
                {
                    DocumentId = documentId,
                    Name       = newFileName,
                    Type       = fileExtension,
                    UserId     = userId,
                    CreateDate = DateTime.Now,
                    Size       = file.Length,
                    Encrypted  = true
                };

                using (var target = new MemoryStream())
                {
                    file.CopyTo(target);
                    fichier.File = protector.Protect(target.ToArray());
                }

                this._context.Files.Add(fichier);
                this._context.SaveChanges();
                return(fichier.ToFichierEntete());
            }
            return(null);
        }
Пример #2
0
 public Generator(List<DbTableInfo> tables, EntityFile file, string dirTemplate)
 {
     this.tables = tables;
     this.file = file;
     this.dirTemplate = dirTemplate;
     entities = new Dictionary<string, EntityInfo>();
 }
Пример #3
0
        public virtual EntityFileOperationResult SaveAs(EntityFile file)
        {
            EntityFileOperationResult result = new EntityFileOperationResult();

            string virtualPath  = Path.Combine(this._commerceDataDir.DataVirtualFolder, file.CommerceName, "Images", file.FileName);
            string physicalPath = Kooboo.Web.Url.UrlUtility.MapPath(virtualPath);

            byte[] data = new byte[file.Data.Length];
            file.Data.Read(data, 0, data.Length);

            FileStream fs = new FileStream(physicalPath, FileMode.Create);

            try
            {
                fs.Write(data, 0, data.Length);
                fs.Flush();
                fs.Close();
            }
            catch (Exception ex)
            {
                fs.Close();
                throw ex;
            }

            result.PhysicalPath = physicalPath;
            result.VirtualPath  = virtualPath;
            return(result);
        }
Пример #4
0
 public DataLite(IHttpContextAccessor context,
                 ILoggerFactory loggerFactory)
 {
     this.logger  = loggerFactory.CreateLogger("RequestInfoLogger");
     this.context = context.HttpContext;
     Initializing(this.context.Session.GetString("StorageName"));
     Accounts = new EntityAccount(Connection);
     Files    = new EntityFile(Connection);
 }
Пример #5
0
 public static FichierEntete ToFichierEntete(this EntityFile entity)
 {
     return(new FichierEntete()
     {
         Id = entity.Id,
         Type = entity.Type,
         Name = entity.Name,
         CreateDate = entity.CreateDate
     });
 }
Пример #6
0
 public static EntityFileModel Map(EntityFile objModel)
 {
     return(new EntityFileModel
     {
         Id = objModel.Id,
         SectionId = objModel.SectionId,
         EntityId = objModel.EntityId,
         FileId = objModel.FileId,
         Section = SectionMap.Map(objModel.Section)
     });
 }
Пример #7
0
        public ActionResult <EntityFile> PostEntityFile([FromBody] EntityFile entityFile)
        {
            using (_unitOfWork)
            {
                _unitOfWork.Create();

                entityFile.Id = Guid.NewGuid();
                _unitOfWork.EntityFile.Add(entityFile);

                _unitOfWork.Commit();
                return(Ok(entityFile));
            }
        }
        public void SplitsFolderName()
        {
            var entityId = Guid.NewGuid();
            var fileId   = Guid.NewGuid();
            var file     = new EntityFile(1, "AccountFile", entityId, fileId, 1, new byte[] { 0 });

            Assert.NotNull(file);
            Assert.NotNull(file.FolderNames);
            Assert.NotEmpty(file.FolderNames);
            Assert.Equal("AccountFile", file.FolderNames[0]);
            Assert.Equal(entityId.ToString(), file.FolderNames[1]);
            Assert.Equal(fileId.ToString(), file.FolderNames[2]);
        }
        public void CreatesRemoteFolderPath()
        {
            var entityId = Guid.NewGuid();
            var fileId   = Guid.NewGuid();
            var file     = new EntityFile(1, "AccountFile", entityId, fileId, 1, new byte[] { 0 });

            var remoteFolderPath = file.GetRemoteFolderPath();

            Assert.NotNull(file);
            Assert.NotNull(file.Entity);
            Assert.NotNull(file.EntityId);
            Assert.NotNull(file.FileId);
            Assert.Equal($"AccountFile/{entityId.ToString()}/{fileId.ToString()}/", remoteFolderPath);
        }
        /// <summary>
        /// Помещает файл в файловое хранилище.
        /// </summary>
        /// <param name="entityFile">Выгружаемый файл</param>
        /// <param name="allFiles">Все файлы сущности</param>
        public async Task <bool> PutWithHttp(EntityFile entityFile, IEnumerable <EntityFile> allFiles)
        {
            if (entityFile?.Data == null || !(entityFile.FolderNames?.Count > 0))
            {
                return(false);
            }
            try
            {
                using (var handler = new HttpClientHandler {
                    Credentials = new NetworkCredential(UserName, Password), PreAuthenticate = true
                })
                    using (var client = new HttpClient(handler)
                    {
                        BaseAddress = new Uri(ServerUrl)
                    })
                    {
                        var requestMessage =
                            new HttpRequestMessage(HttpMethod.Put, new Uri(ServerUrl + entityFile.GetRemotePath()))
                        {
                            Content = new ByteArrayContent(entityFile.Data),
                            Version = HttpVersion.Version11,
                            Headers =
                            {
                                { HttpRequestHeader.Translate.ToString(),     "f"                        },
                                { HttpRequestHeader.ContentType.ToString(),   "application/octet-stream" },
                                { HttpRequestHeader.ContentLength.ToString(), entityFile.Data.ToString() }
                            }
                        };

                        var result = await client.SendAsync(requestMessage, HttpCompletionOption.ResponseContentRead);

                        var entityFiles = allFiles.ToList();
                        Log.Info(Utils.ShowPercentProgress("Выгружаем файлы", entityFiles.IndexOf(entityFile), entityFiles.Count));
                        Log.Info($"Файл: #{entityFile.Number.ToString()} {entityFile.Entity}/{entityFile.EntityId}/{entityFile.FileId}/{entityFile.Version} {entityFile.Data.Length / 1024.0:####0.######} КБ ({entityFile.Data.Length / (1024.0 * 1024.0):####0.######} МБ) {result.StatusCode.ToString()}");

                        return(true);
                    }
            }
            catch (WebException ex)
            {
                Console.WriteLine(ex.Message);
                Log.Debug(ex);
                return(false);
            }
            catch (Exception ex)
            {
                ExceptionHandler.LogExceptionToConsole(ex);
                throw ex;
            }
        }
Пример #11
0
        public void Test_Save()
        {
            EntityFile entityFile = new EntityFile()
            {
                FileName    = "image1.png",
                Data        = new MemoryStream(new byte[] { 0, 1, 2, 3 }),
                ContentType = "image"
            };
            var result = entityFileProvider.Save(entityFile, "Tests");
            var expectedPhysicalPath = Path.Combine(commerceDataDir.DataPhysicalPath, "Tests", entityFile.FileName);
            var expectedVirtualPath  = UrlUtility.Combine(commerceDataDir.DataVirutalPath, "Tests", entityFile.FileName);

            Assert.AreEqual(expectedPhysicalPath, result.PhysicalPath);
            Assert.AreEqual(expectedVirtualPath, result.VirtualPath);
        }
        public void Creates()
        {
            var entityId = Guid.NewGuid();
            var fileId   = Guid.NewGuid();
            var file     = new EntityFile(1, "AccountFile", entityId, fileId, 1, new byte[] { 0 });

            Assert.NotNull(file);
            Assert.NotNull(file.Entity);
            Assert.Equal("AccountFile", file.Entity);
            Assert.NotNull(file.EntityId);
            Assert.False(Guid.Empty == Guid.Parse(file.EntityId));
            Assert.NotNull(file.FileId);
            Assert.False(Guid.Empty == Guid.Parse(file.FileId));
            Assert.NotNull(file.Version);
            Assert.True(file.Version == "1");
            Assert.NotNull(file.Data);
            Assert.NotEmpty(file.Data);
            Assert.True(file.Data.Length == 1);
        }
Пример #13
0
        public async Task GenerateEntities(EntityGenerationRequest request)
        {
            var connectionString = string.Format(@"Data Source={0};Initial Catalog={1};User Id={2};Password={3};",
                                                 request.Server, request.Database, request.Username, request.Password);

            var  generator          = CodeFirstGenerator.Load(connectionString, request.EntityDefinitions.ToDictionary(def => def.TableName, def => def.EntityName));
            bool makePartialClasses = false;

            EntityFile entityFile = FilePathSplitter.DetermineEntityFile(request.OutputPath);

            var projectDirectoryPaths = Directory.GetFiles(entityFile.EntityOutputPath, "*.csproj");

            if (projectDirectoryPaths.Length == 1)
            {
                var projectDirectoryPath = projectDirectoryPaths.Single();

                var project = new Project(projectDirectoryPath);

                var serverPath = FilePathSplitter.DetermineServerPath(request.OutputPath);

                foreach (var entityDefinition in request.EntityDefinitions.Where(table => !generator.IsManyToManyMappingTable(table.TableName)))
                {
                    var tryToSave = _SearchForExistingTableName(entityDefinition.TableName, serverPath);

                    if (tryToSave)
                    {
                        var pocoEntity = EntityGeneratorEngine.GeneratePocoEntity(request.Namespace, entityDefinition.TableName, entityDefinition.EntityName, makePartialClasses, generator);
                        _SaveOutput(request.OutputPath, Path.Combine(entityDefinition.EntityName + ".cs"), entityFile.EntityOutputPathPrefix, pocoEntity, project);

                        var mapping = EntityGeneratorEngine.GenerateMapping(request.Namespace + ".Mapping", entityDefinition.TableName, entityDefinition.EntityName, generator);
                        _SaveOutput(request.OutputPath, Path.Combine("Mapping", entityDefinition.EntityName + "Map.cs"), entityFile.EntityOutputPathPrefix, mapping, project);
                    }
                }

                if (project.IsDirty)
                {
                    _SortProjectDirectory(projectDirectoryPath);
                }

                ProjectCollection.GlobalProjectCollection.UnloadProject(project);
            }
        }
Пример #14
0
        public async Task <IActionResult> PutEntityFile([FromRoute] Guid id, [FromBody] EntityFile entityFile)
        {
            using (_unitOfWork)
            {
                _unitOfWork.Create();

                if (entityFile == null)
                {
                    return(NotFound());
                }

                if (id != entityFile.Id)
                {
                    return(BadRequest());
                }
                _unitOfWork.EntityFile.Update(entityFile);
                _unitOfWork.Commit();
                return(Ok(entityFile));
            }
        }
Пример #15
0
        public Guid AddDocument(IFormCollection fileCollection, Guid userId)
        {
            if (fileCollection == null)
            {
                return(Guid.Empty);
            }
            var document = new EntityDocument();

            document.UserId     = userId;
            document.Files      = new List <EntityFile>();
            document.CreateDate = DateTime.Now;

            foreach (var file in fileCollection.Files)
            {
                if (file.Length > 0)
                {
                    var fileName      = Path.GetFileName(file.FileName);
                    var fileExtension = Path.GetExtension(fileName);
                    var newFileName   = String.Concat(fileName, fileExtension);

                    var fichier = new EntityFile()
                    {
                        Name       = newFileName,
                        Type       = fileExtension,
                        UserId     = document.UserId,
                        CreateDate = DateTime.Now
                    };

                    using (var target = new MemoryStream())
                    {
                        file.CopyTo(target);
                        fichier.File = target.ToArray();
                    }
                    document.Files.Add(fichier);
                }
            }

            this._context.Documents.Add(document);
            this._context.SaveChanges();
            return(document.Id);
        }
Пример #16
0
 public FileUtil(EnumTipoArquivo tipoArquivo)
 {
     EntityFile = new EntityFile(tipoArquivo);
     Path       = EntityFile.Path;
 }
Пример #17
0
        public void SetNames(EntityFile file, string tableName)
        {
            var v = file.Variables;
            EntityName = v.EntityName.Replace("[EntityName]", tableName);
            if (NameCase != EnumNameCase.None)
            {
                var names = EntityName.Split(new char[] { '_', ' ' }, StringSplitOptions.RemoveEmptyEntries);
                for (int i = 0; i < names.Length; i++)
                {
                    if (NameCase == EnumNameCase.Lower)
                        names[i] = names[i].ToUpper();
                    if (NameCase == EnumNameCase.Upper)
                        names[i] = names[i].ToUpper();
                    if (NameCase == EnumNameCase.Camel)
                        names[i] = names[i].Substring(0, 1).ToLower() + names[i].Substring(1, names[i].Length - 1);
                    if (NameCase == EnumNameCase.Pascal)
                        names[i] = names[i].Substring(0, 1).ToUpper() + names[i].Substring(1, names[i].Length - 1).ToLower();
                }

                EntityName = string.Join("", names);
            }

            var fv = file.Variables;
            IRepositoryName = fv.IRepositoryName.Replace("[EntityName]", EntityName);
            RepositoryName = fv.RepositoryName.Replace("[EntityName]", EntityName);
            IBusinessName = fv.IBusinessName.Replace("[EntityName]", EntityName);
            BusinessName = fv.BusinessName.Replace("[EntityName]", EntityName);
            ConfigurationName = fv.ConfigurationName.Replace("[EntityName]", EntityName);
            ConnectionString = fv.ConnectionString;
            ContextName = fv.ContextName;
        }