private static async Task <CodeForeign> GetOrAddForeign(IDataContract contract, Guid entityId, CodeForeign fore)
{
CodeForeign foreign = contract.CodeForeigns.FirstOrDefault(m => m.EntityId == entityId && m.SelfNavigation == fore.SelfNavigation);
if (foreign != null)
{
return(foreign);
}
CodeForeignInputDto dto = new CodeForeignInputDto()
{
SelfNavigation = fore.SelfNavigation,
SelfForeignKey = fore.SelfForeignKey,
OtherEntity = fore.OtherEntity,
OtherNavigation = fore.OtherNavigation,
IsRequired = fore.IsRequired,
DeleteBehavior = fore.DeleteBehavior,
ForeignRelation = fore.ForeignRelation,
EntityId = entityId
};
await contract.UpdateCodeForeigns(dto);
foreign = contract.CodeForeigns.First(m => m.EntityId == entityId && m.SelfNavigation == fore.SelfNavigation);
return(foreign);
}
public void Init()
{
CodeForeign[] foreigns = new CodeForeign[0];
_provider.ExecuteScopedWork(provider =>
{
IDataContract contract = provider.GetRequiredService <IDataContract>();
foreigns = contract.CodeForeigns.Where(m => m.EntityId == Entity.Id).ToArray();
});
Foreigns.Clear();
foreach (CodeForeign foreign in foreigns)
{
ForeignViewModel model = _provider.GetRequiredService <ForeignViewModel>();
model = foreign.MapTo(model);
Foreigns.Add(model);
}
}
/// <summary>
/// 更新实体外键信息信息
/// </summary>
/// <param name="dtos">包含更新信息的实体外键信息</param>
/// <returns>业务操作结果</returns>
public async Task <OperationResult> UpdateCodeForeigns(params CodeForeignInputDto[] dtos)
{
List <string> names = new List <string>();
UnitOfWork.EnableTransaction();
foreach (var dto in dtos)
{
dto.Validate();
CodeEntity entity = await EntityRepository.GetAsync(dto.EntityId);
if (entity == null)
{
return(new OperationResult(OperationResultType.Error, $"编号为“{dto.EntityId}”的实体信息不存在"));
}
if (await CheckCodeForeignExists(m => m.SelfNavigation == dto.SelfNavigation && m.EntityId == dto.EntityId, dto.Id))
{
return(new OperationResult(OperationResultType.Error, $"实体“{entity.Name}”中名称为“{dto.SelfNavigation}”的外键信息已存在"));
}
int count;
if (dto.Id == default)
{
CodeForeign foreign = dto.MapTo <CodeForeign>();
count = await ForeignRepository.InsertAsync(foreign);
}
else
{
CodeForeign foreign = await ForeignRepository.GetAsync(dto.Id);
foreign = dto.MapTo(foreign);
count = await ForeignRepository.UpdateAsync(foreign);
}
if (count > 0)
{
names.Add($"{entity.Name}-{dto.SelfNavigation}");
}
}
await UnitOfWork.CommitAsync();
return(names.Count > 0
? new OperationResult(OperationResultType.Success, $"导航属性“{names.ExpandAndToString()}”更新成功")
: OperationResult.NoChanged);
}
private async Task ImportProject(string file)
{
string json = await File.ReadAllTextAsync(file);
CodeProject proj = json.FromJsonString <CodeProject>();
if (proj == null)
{
return;
}
await _provider.ExecuteScopedWorkAsync(async provider =>
{
IUnitOfWork unitOfWork = provider.GetUnitOfWork(true);
IDataContract contract = provider.GetRequiredService <IDataContract>();
CodeProject project = await GetOrAddProject(contract, proj);
foreach (var mod in proj.Modules)
{
CodeModule module = await GetOrAddModule(contract, project.Id, mod);
foreach (var en in mod.Entities)
{
CodeEntity entity = await GetOrAddEntity(contract, module.Id, en);
foreach (var prop in en.Properties)
{
CodeProperty property = await GetOrAddProperty(contract, entity.Id, prop);
}
foreach (var fore in en.Foreigns)
{
CodeForeign foreign = await GetOrAddForeign(contract, entity.Id, fore);
}
}
}
foreach (CodeProjectTemplate projTpl in proj.ProjectTemplates)
{
if (projTpl.Template == null)
{
continue;
}
CodeTemplate tpl = contract.CodeTemplates.FirstOrDefault(m => m.Name == projTpl.Template.Name);
if (tpl == null)
{
CodeTemplateInputDto dto = projTpl.Template.MapTo <CodeTemplateInputDto>();
dto.Id = default;
var result = await contract.UpdateCodeTemplates(dto);
if (result.Succeeded)
{
tpl = result.Data[0];
}
}
projTpl.TemplateId = tpl.Id;
project.ProjectTemplates.Add(projTpl);
}
await unitOfWork.CommitAsync();
});
Init();
Helper.Output($"文件“{file}”导入完毕");
}
