Example #1
0
        public async Task <IActionResult> BuildCode(ProjectBuildCodeModel model)
        {
            var result = await _service.BuildCode(model);

            var path = Path.Combine(_commonOptions.TempPath, _codeGeneratorOptions.BuildCodePath, result.Data.Id + ".zip");

            return(PhysicalFile(path, "application/octet-stream", result.Data.Name, true));
        }
Example #2
0
        public async Task <IActionResult> BuildCode(ProjectBuildCodeModel model)
        {
            var result = await _service.BuildCode(model);

            var path   = Path.Combine(_commonOptions.TempPath, _codeGeneratorOptions.BuildCodePath, result.Data.Id + ".zip");
            var memory = new MemoryStream();

            using (var stream = new FileStream(path, FileMode.Open))
            {
                await stream.CopyToAsync(memory);
            }
            memory.Position = 0;
            return(File(memory, "application/octet-stream", result.Data.Name + ".zip"));
        }
Example #3
0
 public Task <IResultModel <ProjectBuildCodeResultModel> > BuildCode(ProjectBuildCodeModel model)
 {
     return(BuildCode(model.Id));
 }
Example #4
0
        public async Task <IResultModel <ProjectBuildCodeResultModel> > BuildCode(ProjectBuildCodeModel model)
        {
            var result  = new ResultModel <ProjectBuildCodeResultModel>();
            var project = await _repository.GetAsync(model.Id);

            if (project == null)
            {
                return(result.Failed("项目不存在"));
            }

            var id         = Guid.NewGuid().ToString();
            var rootPath   = Path.Combine(_commonOptions.TempPath, _codeGeneratorOptions.BuildCodePath);
            var buildModel = new TemplateBuildModel
            {
                RootPath = Path.Combine(rootPath, id),
            };

            //创建项目生成对象
            var projectBuildModel = _mapper.Map <ProjectBuildModel>(project);

            //查询类生成列表
            var classList = await _classRepository.QueryAllByProject(model.Id);

            foreach (var classEntity in classList)
            {
                var classBuildModel = _mapper.Map <ClassBuildModel>(classEntity);
                var propertyList    = await _propertyRepository.QueryByClass(classEntity.Id);

                if (propertyList.Any())
                {
                    //查询属性
                    foreach (var propertyEntity in propertyList)
                    {
                        var propertyBuildModel = _mapper.Map <PropertyBuildModel>(propertyEntity);

                        //如果属性类型是枚举,查询枚举信息
                        if (propertyEntity.Type == PropertyType.Enum && propertyEntity.EnumId.NotEmpty())
                        {
                            var enumEntity = await _enumRepository.GetAsync(propertyEntity.EnumId);

                            propertyBuildModel.Enum = new EnumBuildModel
                            {
                                Name    = enumEntity.Name,
                                Remarks = enumEntity.Remarks
                            };

                            var enumItemList = await _enumItemRepository.QueryByEnum(propertyEntity.EnumId);

                            propertyBuildModel.Enum.ItemList = enumItemList.Select(m => new EnumItemBuildModel
                            {
                                Name    = m.Name,
                                Remarks = m.Remarks,
                                Value   = m.Value
                            }).ToList();
                        }

                        classBuildModel.PropertyList.Add(propertyBuildModel);
                    }
                }


                var modelPropertyList = await _modelPropertyRepository.QueryByClass(classEntity.Id);

                if (modelPropertyList.Any())
                {
                    foreach (var propertyEntity in modelPropertyList)
                    {
                        var modelPropertyBuildModel = _mapper.Map <ModelPropertyBuildModel>(propertyEntity);
                        //如果属性类型是枚举,查询枚举信息
                        if (propertyEntity.Type == PropertyType.Enum && propertyEntity.EnumId.NotEmpty())
                        {
                            var enumEntity = await _enumRepository.GetAsync(propertyEntity.EnumId);

                            modelPropertyBuildModel.Enum = new EnumBuildModel
                            {
                                Name    = enumEntity.Name,
                                Remarks = enumEntity.Remarks
                            };

                            var enumItemList = await _enumItemRepository.QueryByEnum(propertyEntity.EnumId);

                            modelPropertyBuildModel.Enum.ItemList = enumItemList.Select(m => new EnumItemBuildModel
                            {
                                Name    = m.Name,
                                Remarks = m.Remarks,
                                Value   = m.Value
                            }).ToList();
                        }

                        classBuildModel.ModelPropertyList.Add(modelPropertyBuildModel);
                    }
                }

                classBuildModel.Method = await _classMethodRepository.GetByClass(classEntity.Id);

                projectBuildModel.ClassList.Add(classBuildModel);
            }

            buildModel.Project = projectBuildModel;

            var builder = new DefaultTemplateBuilder();

            builder.Build(buildModel);

            ZipFile.CreateFromDirectory(buildModel.RootPath, Path.Combine(rootPath, id + ".zip"));

            var resultModel = new ProjectBuildCodeResultModel
            {
                Id   = id,
                Name = projectBuildModel.Name + ".zip"
            };

            return(result.Success(resultModel));
        }