/// <summary>
/// 创建Service接口
/// </summary>
/// <param name="model"></param>
/// <param name="project"></param>
private void CreateServiceInterface(CreateFileInput model, ProjectItem project)
{
string content_IService = RunTemplate("ApplicationService.IServiceTemplate", model);
string fileName_IService = $"I{model.ClassName}AppService.cs";
AddFileToProjectItem(project, content_IService, fileName_IService);
}
public async Task <string> CreateFileAsync(CreateFileInput input)
{
using (var reader = new StreamReader(input.Content.GetStream()))
{
return(input.Name + ":" + await reader.ReadToEndAsync() + ":" + input.Content.ContentType + ":" + input.Content.FileName);
}
}
/// <summary>
/// 创建Dto文件
/// </summary>
/// <param name="model"></param>
/// <param name="dtoFolder"></param>
private void CreateDtoFile(CreateFileInput model, ProjectItem dtoFolder)
{
string content_Edit = RazorEngine.Engine.Razor.RunCompile("EditDtoTemplate", typeof(CreateFileInput), model);
string fileName_Edit = $"{model.ClassName}EditDto.cs";
AddFileToProjectItem(dtoFolder, content_Edit, fileName_Edit);
string content_List = RazorEngine.Engine.Razor.RunCompile("ListDtoTemplate", typeof(DtoFileModel), model);
string fileName_List = $"{model.ClassName}ListDto.cs";
AddFileToProjectItem(dtoFolder, content_List, fileName_List);
string content_CreateAndUpdate = RazorEngine.Engine.Razor.RunCompile("CreateOrUpdateInputDtoTemplate", typeof(DtoFileModel), model);
string fileName_CreateAndUpdate = $"CreateOrUpdate{model.ClassName}Input.cs";
AddFileToProjectItem(dtoFolder, content_CreateAndUpdate, fileName_CreateAndUpdate);
string content_GetForUpdate = RazorEngine.Engine.Razor.RunCompile("GetForEditOutputDtoTemplate", typeof(DtoFileModel), model);
string fileName_GetForUpdate = $"Get{model.ClassName}ForEditOutput.cs";
AddFileToProjectItem(dtoFolder, content_GetForUpdate, fileName_GetForUpdate);
string content_GetsInput = RazorEngine.Engine.Razor.RunCompile("GetsInputTemplate", typeof(DtoFileModel), model);
string fileName_GetsInput = $"Get{model.ClassName}sInput.cs";
AddFileToProjectItem(dtoFolder, content_GetsInput, fileName_GetsInput);
}
/// <summary>
/// 创建控制器
/// </summary>
/// <param name="model"></param>
/// <param name="project"></param>
private void CreateController(CreateFileInput model, ProjectItem project)
{
string content_Controller = RunTemplate("Controller.ControllerTemplate", model);
string fileName_Controller = $"{model.ClassName}Controller.cs";
AddFileToProjectItem(project, content_Controller, fileName_Controller);
}
/// <summary>
/// 创建验证文件
/// </summary>
/// <param name="model"></param>
/// <param name="dtoFolder"></param>
private void CreateValidatorFile(CreateFileInput model, ProjectItem dtoFolder)
{
string content_Edit = RazorEngine.Engine.Razor.RunCompile("ValidationTemplate", typeof(CreateFileInput), model);
string fileName_Edit = $"{model.ClassName}EditValidator.cs";
AddFileToProjectItem(dtoFolder, content_Edit, fileName_Edit);
}
/// <summary>
/// 创建自定义Automapper映射
/// </summary>
/// <param name="model"></param>
/// <param name="dtoFolder"></param>
private void CreateCustomDtoMapper(CreateFileInput model, ProjectItem dtoFolder)
{
string content_Edit = RazorEngine.Engine.Razor.RunCompile("CustomDtoTemplate", typeof(CreateFileInput), model);
string fileName_Edit = model.AbsoluteNamespace + "DtoMapper.cs";
AddFileToProjectItem(dtoFolder, content_Edit, fileName_Edit);
}
public virtual async Task <CreateFileOutput> CreateAsync(CreateFileInput input)
{
var configuration = _configurationProvider.Get(input.FileContainerName);
CheckFileSize(new Dictionary <string, long> {
{ input.FileName, input.Content?.LongLength ?? 0 }
}, configuration);
if (input.FileType == FileType.RegularFile)
{
CheckFileExtension(new[] { Path.GetExtension(input.FileName) }, configuration);
}
var parent = await TryGetEntityByNullableIdAsync(input.ParentId);
var file = await _fileManager.CreateAsync(input.FileContainerName, input.OwnerUserId, input.FileName,
input.MimeType, input.FileType, parent, input.Content);
await AuthorizationService.CheckAsync(CreateFileOperationInfoModel(file),
new OperationAuthorizationRequirement { Name = FileManagementPermissions.File.Create });
await _repository.InsertAsync(file);
await _fileManager.TrySaveBlobAsync(file, input.Content);
return(await MapToCreateOutputDtoAsync(file));
}
/// <summary>
/// 创建验证基类
/// </summary>
/// <param name="model"></param>
/// <param name="dtoFolder"></param>
private void CreateValidationBase(CreateFileInput model, ProjectItem dtoFolder)
{
string content_Edit = RazorEngine.Engine.Razor.RunCompile("ValidationBaseTemplate", typeof(CreateFileInput), model);
string fileName_Edit = model.AbsoluteNamespace + "Validator.cs";
AddFileToProjectItem(dtoFolder, content_Edit, fileName_Edit);
}
/// <summary>
/// 创建Dto文件
/// </summary>
/// <param name="model"></param>
/// <param name="dtoFolder"></param>
private void CreateDtoFile(CreateFileInput model, ProjectItem dtoFolder)
{
// TODO:读取页面选择属性.并支持创建/修改包含独立属性
string content_GetsInput = RazorEngine.Engine.Razor.RunCompile("GetsInputTemplate", typeof(DtoFileModel), model);
string fileName_GetsInput = $"Get{model.ClassName}sInput.cs";
AddFileToProjectItem(dtoFolder, content_GetsInput, fileName_GetsInput);
string content_List = RazorEngine.Engine.Razor.RunCompile("ListDtoTemplate", typeof(DtoFileModel), model);
string fileName_List = $"{model.ClassName}ListDto.cs";
AddFileToProjectItem(dtoFolder, content_List, fileName_List);
string content_CreateAndUpdate = RazorEngine.Engine.Razor.RunCompile("CreateOrUpdateDtoBaseTemplate", typeof(DtoFileModel), model);
string fileName_CreateAndUpdate = $"{model.ClassName}CreateOrUpdateDtoBase.cs";
AddFileToProjectItem(dtoFolder, content_CreateAndUpdate, fileName_CreateAndUpdate);
string content_Create = RazorEngine.Engine.Razor.RunCompile("CreateDtoTemplate", typeof(DtoFileModel), model);
string fileName_Create = $"{model.ClassName}CreateDto.cs";
AddFileToProjectItem(dtoFolder, content_Create, fileName_Create);
string content_Update = RazorEngine.Engine.Razor.RunCompile("UpdateDtoTemplate", typeof(DtoFileModel), model);
string fileName_Update = $"{model.ClassName}UpdateDto.cs";
AddFileToProjectItem(dtoFolder, content_Update, fileName_Update);
string content_GetForUpdate = RazorEngine.Engine.Razor.RunCompile("GetForEditOutputDtoTemplate", typeof(DtoFileModel), model);
string fileName_GetForUpdate = $"Get{model.ClassName}ForEditOutput.cs";
AddFileToProjectItem(dtoFolder, content_GetForUpdate, fileName_GetForUpdate);
}
public void CreateFile(CreateFileInput model)
{
InitRazorEngine();
ProjectItem applicationProjectItem = SolutionProjectItems.Find(t => t.Name == ApplicationRootNamespace + ".Application");
//首次使用
if (model.FirstUse)
{
//首次初始化，添加通用Dto
var applicationBasicFolder = applicationProjectItem.SubProject.ProjectItems.Item("Dto") ?? applicationProjectItem.SubProject.ProjectItems.AddFolder("Dto");
CreateBasicDto(model, applicationBasicFolder);
//编辑AppConst
SetConst(applicationProjectItem.SubProject);
//创建验证模板
CreateValidationBase(model, applicationProjectItem);
}
//获取当前点击的类所在的项目
Project topProject = SelectProjectItem.ContainingProject;
//添加项目目录结构
var applicationNewFolder = GetDeepProjectItem(applicationProjectItem, ClassAbsolutePathInProject)
?? applicationProjectItem.SubProject.ProjectItems.AddFolder(ClassAbsolutePathInProject);
//添加Dto
var applicationDtoFolder = applicationNewFolder.ProjectItems.Item("Dto") ?? applicationNewFolder.ProjectItems.AddFolder("Dto");
CreateDtoFile(model, applicationDtoFolder);
//设置Autompper映射
ProjectItem customDtoMapperProjectItem = applicationProjectItem.SubProject.ProjectItems.Item(model.AbsoluteNamespace + "DtoMapper.cs");
if (customDtoMapperProjectItem == null)
{ //没有则创建文件
CreateCustomDtoMapper(model, applicationProjectItem);
customDtoMapperProjectItem = applicationProjectItem.SubProject.ProjectItems.Item(model.AbsoluteNamespace + "DtoMapper.cs");
}
EditMapper(customDtoMapperProjectItem, $"{model.Namespace}.{model.DirectoryName}", model.ClassName, model.LocalName);
//参数验证
var applicationValidatorFolder = applicationNewFolder.ProjectItems.Item("Validators") ?? applicationNewFolder.ProjectItems.AddFolder("Validators");
CreateValidatorFile(model, applicationValidatorFolder);
//权限
if (model.AuthorizationService)
{
CreatePermission(model);
}
//应用服务
if (model.ApplicationService)
{
CreateServiceFile(model, applicationNewFolder);
}
//领域服务
if (model.DomainService)
{
ProjectItem currentProjectItem = GetDeepProjectItem(topProject, ClassAbsolutePathInProject);
var coreDomainServiceFolder = currentProjectItem.ProjectItems.Item("DomainService")
?? currentProjectItem.ProjectItems.AddFolder("DomainService");
CreateDomainServiceFile(model, coreDomainServiceFolder);
}
}
/// <summary>
/// 创建自定义Automapper映射
/// </summary>
/// <param name="model"></param>
/// <param name="dtoFolder"></param>
private void CreateMapperFile(CreateFileInput model, ProjectItem dtoFolder)
{
string content_Edit = RunTemplate("MapperTemplate", model);
string fileName_Edit = model.ModuleName + "ApplicationAutoMapperProfile.cs";
AddFileToProjectItem(dtoFolder, content_Edit, fileName_Edit);
}
static public Model.FileRecord uploadFile(VmosoSession session, String filePath, String title, String description, bool dominantActivity)
{
try {
String url = session.Host + "/up/file";
String userAgent = session.GetApiClient().Configuration.UserAgent;
WebClient client = new WebClient();
client.Headers.Add("X-CV-Authorization", session.GetAuthorizationHeader());
client.Headers.Add("User-Agent", userAgent);
byte[] response = client.UploadFile(url, filePath);
var jsonString = System.Text.Encoding.Default.GetString(response);
dynamic dynObj = JsonConvert.DeserializeObject(jsonString);
var file = dynObj[0];
String fileName = file.name;
String fileDownloadId = file.fileDownloadId;
String mimeType = file.mimeType;
int fileSize = file.filesize;
FileRecord fr = new FileRecord();
fr.Type = "file";
fr.Name = title;
fr.Description = description;
fr.Filename = "1";
fr.Originalfilename = fileName;
fr.SiteSelected = "1";
fr.FilestoreDirRoot = "1";
fr.FilestoreFilestore = fileDownloadId;
fr.Mimetype = mimeType;
fr.Filesize = fileSize;
fr.Downloadable = "1";
fr.Simpletype = "1";
fr.DvaultItemFlag = "1";
fr.DvaultItemStatus = "1";
fr.BvrevVersion = 1;
fr.BvrevLastUpdater = 1;
fr.Trashed = "0";
FileApi fileApi = new FileApi(session.GetApiClient());
CreateFileInput createFileInput = new CreateFileInput(fr, dominantActivity, null);
CreateFileResult createFileResult = fileApi.CreateFile(createFileInput);
if (createFileResult.Hdr.Rc == 0)
{
return(createFileResult.File);
}
else
{
throw new Exception("Error uploading file. Rc=" + createFileResult.Hdr.Rc);
}
} catch (Exception ex)
{
throw new Exception("Error uploading file", ex);
}
}
public void CreateFile(CreateFileInput model)
{
// TODO:区分Contracts
InitRazorEngine();
CompileTemplate();
ProjectItem applicationProjectItem = SolutionProjectItems.Find(t => t.Name == ApplicationRootNamespace + ".Application");
//获取当前点击的类所在的项目
Project topProject = SelectProjectItem.ContainingProject;
//添加项目目录结构
var applicationNewFolder = GetDeepProjectItem(applicationProjectItem, ClassAbsolutePathInProject)
?? applicationProjectItem.SubProject.ProjectItems.AddFolder(ClassAbsolutePathInProject);
//添加Dto
var applicationDtoFolder = applicationNewFolder.ProjectItems.Item("Dtos") ?? applicationNewFolder.ProjectItems.AddFolder("Dtos");
CreateDtoFile(model, applicationDtoFolder);
//设置Autompper映射
string moduleName = ClassAbsolutePathInProject.Split(new string[] { "\\" }, StringSplitOptions.RemoveEmptyEntries)[0];
model.ModuleName = moduleName;
ProjectItem moduleItem = applicationProjectItem.SubProject.ProjectItems.Item(moduleName);
ProjectItem mapperItem = moduleItem.ProjectItems.Item(moduleName + "ApplicationAutoMapperProfile.cs");
if (mapperItem == null)
{
CreateMapperFile(model, moduleItem);
}
mapperItem = moduleItem.ProjectItems.Item(moduleName + "ApplicationAutoMapperProfile.cs");
EditMapper(mapperItem, $"{model.Namespace}.{model.DirectoryName}", model.ClassName, model.LocalName);
// TODO:参数验证
//var applicationValidatorFolder = applicationNewFolder.ProjectItems.Item("Validators") ?? applicationNewFolder.ProjectItems.AddFolder("Validators");
//CreateValidatorFile(model, applicationValidatorFolder);
//权限
if (model.AuthorizationService)
{
CreatePermission(model);
}
//应用服务
if (model.ApplicationService)
{
CreateSettingFile(model, applicationNewFolder);
CreateServiceFile(model, applicationNewFolder);
}
//领域服务
if (model.DomainService)
{
ProjectItem currentProjectItem = GetDeepProjectItem(topProject, ClassAbsolutePathInProject);
var coreDomainServiceFolder = currentProjectItem.ProjectItems.Item("DomainService")
?? currentProjectItem.ProjectItems.AddFolder("DomainService");
CreateDomainServiceFile(model, coreDomainServiceFolder);
}
}
/// <summary>
/// 图片上传
/// </summary>
/// <param name="file"></param>
/// <param name="param"></param>
/// <returns></returns>
public async Task <AjaxResponse> Upload(IFormFile file, string param = "")
{
if (file == null)
{
return(await Task.FromResult(new AjaxResponse(false) { Result = "文件不存在" }));
}
#region 1.0 生成文件dto对象
CreateFileInput attachFile = new CreateFileInput
{
FileName = ContentDispositionHeaderValue
.Parse(file.ContentDisposition)
.FileName
.Trim('"'),
Describe = param,
ContentType = file.ContentType,
FileSize = GetFileSize(file.Length),
};
attachFile.FileType = Path.GetExtension(attachFile.FileName);
#endregion
#region 2.0 创建文件的存放路径
string relativeFilePath = $"\\upload\\product\\{Clock.Now.ToString("yyyy_MM")}\\";
string fileDir = hostingEnv.WebRootPath + relativeFilePath;
if (!Directory.Exists(fileDir))
{
Directory.CreateDirectory(fileDir);
}
#endregion
#region 3.0 设置文件的项目路径
string fileName = $"{ Clock.Now.ToString("yyyyMMdd") }_{GetUniqValue()}{attachFile.FileType}";
attachFile.FilePath = relativeFilePath.Replace("\\", "/") + $"{fileName}";
#endregion
#region 4.0 保存文件到数据和具体的位置中
var newFile = await _fileAppService.Create(attachFile);
//3:将文件拷贝到对应的位置
string newFilePath = $"{ fileDir }{ fileName }";
using (FileStream fs = System.IO.File.Create(newFilePath))
{
// 复制文件新路径
await file.CopyToAsync(fs);
// 清空缓冲区数据
fs.Flush();
}
#endregion
//返回结果集
return(await Task.FromResult(new AjaxResponse(true) { Result = ObjectMapper.Map <FileDto>(newFile) }));
}
/// <summary>
/// 创建Setting相关类
/// </summary>
/// <param name="model"></param>
/// <param name="dtoFolder"></param>
private void CreateSettingFile(CreateFileInput model, ProjectItem dtoFolder)
{
string content_IService = RunTemplate("ApplicationService.SettingsTemplate", model);
string fileName_IService = $"{model.ClassName}Settings.cs";
AddFileToProjectItem(dtoFolder, content_IService, fileName_IService);
string content_Service = RunTemplate("ApplicationService.SettingDefinitionProviderTemplate", model);
string fileName_Service = $"{model.ClassName}SettingDefinitionProvider.cs";
AddFileToProjectItem(dtoFolder, content_Service, fileName_Service);
}
/// <summary>
/// 创建验证文件
/// </summary>
/// <param name="model"></param>
/// <param name="dtoFolder"></param>
private void CreateValidatorFile(CreateFileInput model, ProjectItem dtoFolder)
{
string content_Create = RunTemplate("Validation.CreateValidationTemplate", model);
string fileName_Create = $"{model.ClassName}CreateValidator.cs";
AddFileToProjectItem(dtoFolder, content_Create, fileName_Create);
string content_Update = RunTemplate("Validation.UpdateValidationTemplate", model);
string fileName_Update = $"{model.ClassName}UpdateValidator.cs";
AddFileToProjectItem(dtoFolder, content_Update, fileName_Update);
}
/// <summary>
/// 创建仓储文件
/// </summary>
/// <param name="model"></param>
/// <param name="coreFolder"></param>
private void CreateRepositoryFile(CreateFileInput model, ProjectItem interfaceFolder, ProjectItem implementFolder)
{
string contentAuthorizationProvider = RunTemplate("Repository.IRepositoryTemplate", model);
string fileNameAuthorizationProvider = $"I{model.ClassName}Repository.cs";
AddFileToProjectItem(interfaceFolder, contentAuthorizationProvider, fileNameAuthorizationProvider);
string contentPermissionName = RunTemplate("Repository.RepositoryTemplate", model);
string fileNamePermissionName = model.ClassName + "Repository.cs";
AddFileToProjectItem(implementFolder, contentPermissionName, fileNamePermissionName);
}
/// <summary>
/// 创建Setting相关类
/// </summary>
/// <param name="model"></param>
/// <param name="dtoFolder"></param>
private void CreateSettingFile(CreateFileInput model, ProjectItem dtoFolder)
{
string content_IService = RazorEngine.Engine.Razor.RunCompile("SettingsTemplate", typeof(CreateFileInput), model);
string fileName_IService = $"{model.ClassName}Settings.cs";
AddFileToProjectItem(dtoFolder, content_IService, fileName_IService);
string content_Service = RazorEngine.Engine.Razor.RunCompile("SettingDefinitionProviderTemplate", typeof(CreateFileInput), model);
string fileName_Service = $"{model.ClassName}SettingDefinitionProvider.cs";
AddFileToProjectItem(dtoFolder, content_Service, fileName_Service);
}
/// <summary>
/// 上传图片的方法
/// </summary>
/// <param name="file"></param>
/// <param name="module"></param>
/// <returns></returns>
private async Task <FileDto> SaveFile(IFormFile file, string module)
{
if (file == null)
{
throw new UserFriendlyException("文件不存在");
}
#region 1.0 生成文件dto对象
CreateFileInput attachFile = new CreateFileInput
{
FileName = ContentDispositionHeaderValue
.Parse(file.ContentDisposition)
.FileName
.Trim('"'),
Describe = "",
Module = module,
ContentType = file.ContentType,
FileSize = GetFileSize(file.Length),
};
attachFile.FileType = Path.GetExtension(attachFile.FileName);
#endregion
#region 2.0 创建文件的存放路径
string relativeFilePath = $"\\upload\\{module}\\{Clock.Now.ToString("yyyy_MM")}\\";
string fileDir = hostingEnv.WebRootPath + relativeFilePath;
if (!Directory.Exists(fileDir))
{
Directory.CreateDirectory(fileDir);
}
#endregion
#region 3.0 设置文件的项目路径
string fileName = $"{ Clock.Now.ToString("yyyyMMdd") }_{GetUniqValue()}{attachFile.FileType}";
attachFile.FilePath = relativeFilePath.Replace("\\", "/") + $"{fileName}";
#endregion
#region 4.0 保存文件到数据和具体的位置中
var newFile = await _fileAppService.Create(attachFile);
//3:将文件拷贝到对应的位置
string newFilePath = $"{ fileDir }{ fileName }";
using (FileStream fs = System.IO.File.Create(newFilePath))
{
// 复制文件新路径
await file.CopyToAsync(fs);
// 清空缓冲区数据
fs.Flush();
}
#endregion
return(await Task.FromResult(newFile));
}
/// <summary>
/// 创建基础Dto
/// </summary>
/// <param name="model"></param>
/// <param name="dtoFolder"></param>
private void CreateBasicDto(CreateFileInput model, ProjectItem dtoFolder)
{
string content_PagedAndSorted = RazorEngine.Engine.Razor.RunCompile("PagedAndSortedTemplate", typeof(CreateFileInput), model);
string fileName_PagedAndSorted = $"PagedAndSortedInputDto.cs";
AddFileToProjectItem(dtoFolder, content_PagedAndSorted, fileName_PagedAndSorted);
string content_Paged = RazorEngine.Engine.Razor.RunCompile("PagedInputTemplate", typeof(CreateFileInput), model);
string fileName_Paged = $"PagedInputDto.cs";
AddFileToProjectItem(dtoFolder, content_Paged, fileName_Paged);
}
/// <summary>
/// 创建Service类
/// </summary>
/// <param name="applicationStr">根命名空间</param>
/// <param name="name">类名</param>
/// <param name="dtoFolder">父文件夹</param>
/// <param name="dirName">类所在文件夹目录</param>
private void CreateServiceFile(CreateFileInput model, ProjectItem dtoFolder)
{
string content_IService = RazorEngine.Engine.Razor.RunCompile("IServiceTemplate", typeof(CreateFileInput), model);
string fileName_IService = $"I{model.ClassName}AppService.cs";
AddFileToProjectItem(dtoFolder, content_IService, fileName_IService);
string content_Service = RazorEngine.Engine.Razor.RunCompile("ServiceTemplate", typeof(CreateFileInput), model);
string fileName_Service = $"{model.ClassName}AppService.cs";
AddFileToProjectItem(dtoFolder, content_Service, fileName_Service);
}
/// <summary>
/// 创建领域服务文件
/// </summary>
/// <param name="model"></param>
/// <param name="coreFolder"></param>
private void CreateDomainServiceFile(CreateFileInput model, ProjectItem coreFolder)
{
string contentAuthorizationProvider = RazorEngine.Engine.Razor.RunCompile("IDomainServiceTemplate", typeof(CreateFileInput), model);
string fileNameAuthorizationProvider = $"I{model.ClassName}Manager.cs";
AddFileToProjectItem(coreFolder, contentAuthorizationProvider, fileNameAuthorizationProvider);
string contentPermissionName = RazorEngine.Engine.Razor.RunCompile("DomainServiceTemplate", typeof(CreateFileInput), model);
string fileNamePermissionName = model.ClassName + "Manager.cs";
AddFileToProjectItem(coreFolder, contentPermissionName, fileNamePermissionName);
}
/// <summary>
/// 创建授权文件
/// </summary>
/// <param name="model"></param>
/// <param name="coreFolder"></param>
private void CreateAuthorizationFile(CreateFileInput model, ProjectItem coreFolder)
{
string contentAuthorizationProvider = RazorEngine.Engine.Razor.RunCompile("AppAuthorizationProviderTemplate", typeof(CreateFileInput), model);
string fileNameAuthorizationProvider = model.ClassName + "AuthorizationProvider.cs";
AddFileToProjectItem(coreFolder, contentAuthorizationProvider, fileNameAuthorizationProvider);
string contentPermissionName = RazorEngine.Engine.Razor.RunCompile("AppPermissionName", typeof(CreateFileInput), model);
string fileNamePermissionName = model.ClassName + "PermissionName.cs";
AddFileToProjectItem(coreFolder, contentPermissionName, fileNamePermissionName);
}
public async Task CreateDirectoryAsync(CreateDirectoryModel input)
{
var dto = new CreateFileInput
{
FileContainerName = input.FileContainerName,
OwnerUserId = input.OwnerUserId,
FileName = input.DirectoryName,
FileType = FileType.Directory,
MimeType = null,
ParentId = input.ParentId,
Content = null
};
await _service.CreateAsync(dto);
}
/// <summary>
/// 创建Dto
/// </summary>
/// <param name="model"></param>
/// <param name="applicationProjectItem"></param>
/// <param name="dtoFolder"></param>
private void CreateDtos(CreateFileInput model, ProjectItem applicationProjectItem, ProjectItem dtoFolder)
{
CreateDtoFile(model, dtoFolder);
//设置Autompper映射
ProjectItem moduleItem = applicationProjectItem.SubProject.ProjectItems.Item(model.ModuleName);
ProjectItem mapperItem = moduleItem.ProjectItems.Item(model.ModuleName + "ApplicationAutoMapperProfile.cs");
if (mapperItem == null)
{
CreateMapperFile(model, moduleItem);
}
mapperItem = moduleItem.ProjectItems.Item(model.ModuleName + "ApplicationAutoMapperProfile.cs");
EditMapper(mapperItem, model.Namespace, model.DirectoryName, model.Prefix, model.ClassName, model.LocalName);
}
private async Task <string> SaveFile(IFormFile file, string account)
{
if (file == null)
{
return(await Task.FromResult("文件不存在"));
}
#region 1.0 生成文件dto对象
CreateFileInput attachFile = new CreateFileInput
{
FileName = ContentDispositionHeaderValue
.Parse(file.ContentDisposition)
.FileName
.Trim('"'),
ContentType = file.ContentType,
};
attachFile.FileType = Path.GetExtension(attachFile.FileName);
#endregion
#region 2.0 创建文件的存放路径
string relativeFilePath = $"\\upload\\user\\{account}\\";
string fileDir = hostingEnv.WebRootPath + relativeFilePath;
if (!Directory.Exists(fileDir))
{
Directory.CreateDirectory(fileDir);
}
#endregion
#region 3.0 设置文件的项目路径
string fileName = $"{ account }{attachFile.FileType}";
attachFile.FilePath = relativeFilePath.Replace("\\", "/") + $"{fileName}";
#endregion
#region 4.0 保存文件到数据和具体的位置中
//3:将文件拷贝到对应的位置
string newFilePath = $"{ fileDir }{ fileName }";
using (FileStream fs = System.IO.File.Create(newFilePath))
{
// 复制文件新路径
await file.CopyToAsync(fs);
// 清空缓冲区数据
fs.Flush();
}
#endregion
return(await Task.FromResult(attachFile.FilePath));
}
/// <summary>
/// 创建Service类
/// </summary>
/// <param name="applicationStr">根命名空间</param>
/// <param name="name">类名</param>
/// <param name="project">父文件夹</param>
/// <param name="dirName">类所在文件夹目录</param>
private void CreateServiceClass(CreateFileInput model, ProjectItem project)
{
string content_Service = String.Empty;
if (model.Setting.AuthorizationService)
{
content_Service = RunTemplate("ApplicationService.ServiceAuthTemplate", model);
}
else
{
content_Service = RunTemplate("ApplicationService.ServiceTemplate", model);
}
string fileName_Service = $"{model.ClassName}AppService.cs";
AddFileToProjectItem(project, content_Service, fileName_Service);
}
public virtual async Task <IActionResult> OnPostAsync()
{
var dto = new CreateFileInput
{
FileContainerName = FileContainerName,
OwnerUserId = OwnerUserId,
FileName = DirectoryName,
FileType = FileType.Directory,
MimeType = null,
ParentId = ParentId,
Content = null
};
await _service.CreateAsync(dto);
return(NoContent());
}
private void CreatePermission(CreateFileInput model)
{
Project topProject = SelectProjectItem.ContainingProject;
ProjectItem currentProjectItem = GetDeepProjectItem(topProject, ClassAbsolutePathInProject);
// TODO:自行选择单文件或追加。
// 单文件项目原授权不存在administration则需手动添加
// 多文件需在“”配置
if (model.IsAppend)
{
EditPermission(topProject, model);
}
else
{
var coreAuthorizationFolder = currentProjectItem.ProjectItems.Item("Authorization")
?? currentProjectItem.ProjectItems.AddFolder("Authorization");
CreateAuthorizationFile(model, coreAuthorizationFolder);
}
}
/// <summary>
/// 创建Service类
/// </summary>
/// <param name="applicationStr">根命名空间</param>
/// <param name="name">类名</param>
/// <param name="dtoFolder">父文件夹</param>
/// <param name="dirName">类所在文件夹目录</param>
private void CreateServiceFile(CreateFileInput model, ProjectItem dtoFolder)
{
string content_IService = RazorEngine.Engine.Razor.RunCompile("IServiceTemplate", typeof(CreateFileInput), model);
string fileName_IService = $"I{model.ClassName}AppService.cs";
AddFileToProjectItem(dtoFolder, content_IService, fileName_IService);
// TODO:ServiceTemplate创建及之后
string content_Service = String.Empty;
if (model.AuthorizationService)
{
content_Service = RazorEngine.Engine.Razor.RunCompile("ServiceAuthTemplate", typeof(CreateFileInput), model);
}
else
{
content_Service = RazorEngine.Engine.Razor.RunCompile("ServiceTemplate", typeof(CreateFileInput), model);
}
string fileName_Service = $"{model.ClassName}AppService.cs";
AddFileToProjectItem(dtoFolder, content_Service, fileName_Service);
}
