private async Task <ProjectStructureDTO> GenerateGoConsoleTemplate(string projectName, int projectId, int authorId)
        {
            var projectStructureDTO = new ProjectStructureDTO();

            projectStructureDTO.Id = projectId.ToString();

            var programFile = await _fileService.CreateAsync(new Common.DTO.File.FileCreateDTO()
            {
                Name      = "main.go",
                Content   = TemplateHelper.GoProgramTemplate(),
                Folder    = projectName,
                ProjectId = projectId
                            //FilenameExtension = "go"//maybe better to use enums
            },
                                                             authorId);

            projectStructureDTO.NestedFiles.Add(
                new FileStructureDTO
            {
                Id          = Guid.NewGuid().ToString(),
                Type        = TreeNodeType.Folder,
                Name        = projectName,
                NestedFiles = new List <FileStructureDTO>()
                {
                    new FileStructureDTO()
                    {
                        Id   = programFile.Id,
                        Name = programFile.Name,
                        Type = TreeNodeType.File,
                    }
                }
            });

            return(projectStructureDTO);
        }
Example #2
0
        public async Task <IActionResult> CreateAsync([FromBody] ProjectStructureDTO projectStructureDTO)
        {
            var createdProjectStructure = await _projectStructureService.CreateAsync(projectStructureDTO);

            _logger.LogInformation("created project structure");
            return(CreatedAtAction(nameof(GetByIdAsync), new { id = createdProjectStructure.Id }, createdProjectStructure));
        }
        public async Task <ProjectStructureDTO> CreateAsync(ProjectStructureDTO projectStructureDto)
        {
            var projectStructureCreate  = _mapper.Map <ProjectStructure>(projectStructureDto);
            var createdProjectStructure = await _projectStructureRepository.CreateAsync(projectStructureCreate);

            return(await GetByIdAsync(createdProjectStructure.Id));
        }
Example #4
0
        public async Task <IActionResult> UpdateAsync([FromBody] ProjectStructureDTO projectStructureDTO)
        {
            projectStructureDTO = await _projectStructureService.CalculateProjectStructureSize(projectStructureDTO);

            await _projectStructureService.UpdateAsync(projectStructureDTO);

            _logger.LogInformation("updated project structure");
            return(NoContent());
        }
        public async Task UpdateAsync(ProjectStructureDTO projectStructureDTO)
        {
            var currentProjectStructureDto = await GetByIdAsync(projectStructureDTO.Id);

            currentProjectStructureDto.NestedFiles = projectStructureDTO.NestedFiles;

            var projectStructureUpdate = _mapper.Map <ProjectStructure>(currentProjectStructureDto);
            await _projectStructureRepository.UpdateAsync(projectStructureUpdate);
        }
        public async Task <ProjectStructureDTO> CalculateProjectStructureSize(ProjectStructureDTO projectStructureDTO)
        {
            List <FileStructureDTO> rootfolder = new List <FileStructureDTO>();

            foreach (var item in projectStructureDTO.NestedFiles)
            {
                rootfolder.Add(await CalculateSize(item));
            }
            projectStructureDTO.NestedFiles = rootfolder;
            return(projectStructureDTO);
        }
        private async Task <ProjectStructureDTO> GenerateCSharpConsoleTemplate(string projectName, int projectId, int authorId)
        {
            var projectStructureDTO = new ProjectStructureDTO();

            projectStructureDTO.Id = projectId.ToString();

            var programFile = await _fileService.CreateAsync(new Common.DTO.File.FileCreateDTO()
            {
                Name      = "Program.cs",
                Content   = TemplateHelper.CSharpProgramTemplate(projectName.Capitalize()),
                Folder    = projectName,
                ProjectId = projectId
                            //FilenameExtension = "cs"//maybe better to use enums
            },
                                                             authorId);

            var projectFile = await _fileService.CreateAsync(new Common.DTO.File.FileCreateDTO()
            {
                Name      = projectName.Capitalize() + ".csproj",//create helper with this code)
                Content   = TemplateHelper.CSharpCsprojTemplate(),
                Folder    = projectName,
                ProjectId = projectId
                            //FilenameExtension = "csproj"//maybe better to use enums
            },
                                                             authorId);

            projectStructureDTO.NestedFiles.Add(
                new FileStructureDTO
            {
                Id          = Guid.NewGuid().ToString(),
                Type        = TreeNodeType.Folder,
                Name        = projectName,
                NestedFiles = new List <FileStructureDTO>()
                {
                    new FileStructureDTO()
                    {
                        Id   = programFile.Id,
                        Name = programFile.Name,
                        Type = TreeNodeType.File,
                    },
                    new FileStructureDTO()
                    {
                        Id   = projectFile.Id,
                        Name = projectFile.Name,
                        Type = TreeNodeType.File,
                    }
                }
            });

            return(projectStructureDTO);
        }
        public async Task <ProjectStructureDTO> CreateEmptyAsync(int projectId, string projectName)
        {
            var emptyStructureDTO = new ProjectStructureDTO()
            {
                Id = projectId.ToString()
            };
            var initialFileStructure = new FileStructureDTO()
            {
                Type    = TreeNodeType.Folder,
                Id      = Guid.NewGuid().ToString(),
                Details = $"Super important details of file {projectName}",
                Name    = projectName
            };

            emptyStructureDTO.NestedFiles.Add(initialFileStructure);

            var emptyStructure          = _mapper.Map <ProjectStructure>(emptyStructureDTO);
            var createdProjectStructure = await _projectStructureRepository.CreateAsync(emptyStructure);

            return(await GetByIdAsync(createdProjectStructure.Id));
        }