public async Task <Result <KAttributeDto> > GetAsync(Guid id)
{
var resService = new Result <KAttributeDto>();
try
{
var ctx = GetOpenConnection();
var kattributes = new GenericRepositoryEF <KntDbContext, KAttribute>(ctx);
var resRep = await kattributes.GetAsync((object)id);
if (!resRep.IsValid)
{
CopyErrorList(resRep.ErrorList, resService.ErrorList);
}
resRep = kattributes.LoadCollection(resRep.Entity, tv => tv.KAttributeTabulatedValues);
if (!resRep.IsValid)
{
CopyErrorList(resRep.ErrorList, resService.ErrorList);
}
//
resService.Entity = resRep.Entity?.GetSimpleDto <KAttributeDto>();
resService.Entity.KAttributeValues = resRep.Entity?.KAttributeTabulatedValues?
.Select(_ => _.GetSimpleDto <KAttributeTabulatedValueDto>()).OrderBy(_ => _.Order).ToList();
await CloseIsTempConnection(ctx);
}
catch (Exception ex)
{
AddExecptionsMessagesToErrorsList(ex, resService.ErrorList);
}
return(ResultDomainAction(resService));
}
public async Task <Result <FolderDto> > GetAsync(Guid?folderId, int?folderNumber)
{
var resService = new Result <FolderDto>();
try
{
var ctx = GetOpenConnection();
var folders = new GenericRepositoryEF <KntDbContext, Folder>(ctx);
Result <Folder> resRep;
if (folderId != null)
{
resRep = await folders.GetAsync((object)folderId);
}
else
{
resRep = await folders.GetAsync(f => f.FolderNumber == folderNumber);
}
// KNote template ... load here aditionals properties for FolderDto
resRep = folders.LoadReference(resRep.Entity, n => n.ParentFolder);
// Map to dto
resService.Entity = resRep.Entity?.GetSimpleDto <FolderDto>();
resService.Entity.ParentFolderDto = new FolderDto();
resService.Entity.ParentFolderDto = resRep.Entity?.ParentFolder?.GetSimpleDto <FolderDto>();
var resultChilds = await GetTreeAsync(resService.Entity.FolderId);
resService.Entity.ChildFolders = resultChilds.Entity;
resService.ErrorList = resRep.ErrorList;
await CloseIsTempConnection(ctx);
}
catch (Exception ex)
{
AddExecptionsMessagesToErrorsList(ex, resService.ErrorList);
}
return(ResultDomainAction(resService));
}
public async Task <Result <NoteTypeDto> > GetAsync(Guid id)
{
var response = new Result <NoteTypeDto>();
try
{
var ctx = GetOpenConnection();
var noteTypes = new GenericRepositoryEF <KntDbContext, NoteType>(ctx);
var resGenRep = await noteTypes.GetAsync((object)id);
response.Entity = resGenRep.Entity?.GetSimpleDto <NoteTypeDto>();
response.ErrorList = resGenRep.ErrorList;
await CloseIsTempConnection(ctx);
}
catch (Exception ex)
{
AddExecptionsMessagesToErrorsList(ex, response.ErrorList);
}
return(ResultDomainAction(response));
}
public async Task <Result <SystemValueDto> > GetAsync(string scope, string key)
{
var resService = new Result <SystemValueDto>();
try
{
var ctx = GetOpenConnection();
var systemValues = new GenericRepositoryEF <KntDbContext, SystemValue>(ctx);
var resRep = await systemValues.GetAsync(sv => sv.Scope == scope && sv.Key == key);
resService.Entity = resRep.Entity?.GetSimpleDto <SystemValueDto>();
resService.ErrorList = resRep.ErrorList;
await CloseIsTempConnection(ctx);
}
catch (Exception ex)
{
AddExecptionsMessagesToErrorsList(ex, resService.ErrorList);
}
return(ResultDomainAction(resService));
}
public async Task <Result <FolderDto> > UpdateAsync(FolderDto entity)
{
var resGenRep = new Result <Folder>();
var response = new Result <FolderDto>();
try
{
var ctx = GetOpenConnection();
var folders = new GenericRepositoryEF <KntDbContext, Folder>(ctx);
var resGenRepGet = await folders.GetAsync(entity.FolderId);
Folder entityForUpdate;
if (resGenRepGet.IsValid)
{
entityForUpdate = resGenRepGet.Entity;
entityForUpdate.SetSimpleDto(entity);
entityForUpdate.ModificationDateTime = DateTime.Now;
resGenRep = await folders.UpdateAsync(entityForUpdate);
}
else
{
resGenRep.Entity = null;
resGenRep.AddErrorMessage("Can't find entity for update.");
}
response.Entity = resGenRep.Entity?.GetSimpleDto <FolderDto>();
response.ErrorList = resGenRep.ErrorList;
await CloseIsTempConnection(ctx);
}
catch (Exception ex)
{
AddExecptionsMessagesToErrorsList(ex, response.ErrorList);
}
return(ResultDomainAction(response));
}
public async Task <Result <SystemValueDto> > UpdateAsync(SystemValueDto entity)
{
var resGenRep = new Result <SystemValue>();
var response = new Result <SystemValueDto>();
try
{
var ctx = GetOpenConnection();
var systemValues = new GenericRepositoryEF <KntDbContext, SystemValue>(ctx);
var resGenRepGet = await systemValues.GetAsync(entity.SystemValueId);
SystemValue entityForUpdate;
if (resGenRepGet.IsValid)
{
entityForUpdate = resGenRepGet.Entity;
entityForUpdate.SetSimpleDto(entity);
resGenRep = await systemValues.UpdateAsync(entityForUpdate);
}
else
{
resGenRep.Entity = null;
resGenRep.AddErrorMessage("Can't find entity for update.");
}
response.Entity = resGenRep.Entity?.GetSimpleDto <SystemValueDto>();
response.ErrorList = resGenRep.ErrorList;
await CloseIsTempConnection(ctx);
}
catch (Exception ex)
{
AddExecptionsMessagesToErrorsList(ex, response.ErrorList);
}
return(ResultDomainAction(response));
}
public async Task <Result <UserDto> > GetAsync(Guid userId)
{
var resService = new Result <UserDto>();
try
{
var ctx = GetOpenConnection();
var users = new GenericRepositoryEF <KntDbContext, User>(ctx);
var resRep = await users.GetAsync((object)userId);
resService.Entity = resRep.Entity?.GetSimpleDto <UserDto>();
resService.ErrorList = resRep.ErrorList;
await CloseIsTempConnection(ctx);
}
catch (Exception ex)
{
AddExecptionsMessagesToErrorsList(ex, resService.ErrorList);
}
return(ResultDomainAction(resService));
}
public async Task <Result <KAttributeDto> > UpdateAsync(KAttributeDto entity)
{
var resGenRep = new Result <KAttribute>();
var response = new Result <KAttributeDto>();
try
{
using (TransactionScope scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
var ctx = GetOpenConnection();
var kattributes = new GenericRepositoryEF <KntDbContext, KAttribute>(ctx);
var resGenRepGet = await kattributes.GetAsync(entity.KAttributeId);
KAttribute entityForUpdate;
if (resGenRepGet.IsValid)
{
// Check notetype in notes.
if (entity.NoteTypeId != null && resGenRepGet.Entity.NoteTypeId != entity.NoteTypeId)
{
var noteKAttributes = new GenericRepositoryEF <KntDbContext, NoteKAttribute>(ctx);
var nAttributes = (await noteKAttributes.GetAllAsync(n => n.KAttributeId == entity.KAttributeId)).Entity;
if (nAttributes.Count > 0)
{
response.AddErrorMessage("You can not change the note type for this attribute. This attribute is already being used by several notes. ");
response.Entity = entity;
}
}
if (response.IsValid)
{
entityForUpdate = resGenRepGet.Entity;
entityForUpdate.SetSimpleDto(entity);
resGenRep = await kattributes.UpdateAsync(entityForUpdate);
response.Entity = resGenRep.Entity?.GetSimpleDto <KAttributeDto>();
var guidsUpdated = new List <Guid>();
foreach (var value in entity.KAttributeValues)
{
var res = await SaveTabulateValueAsync(ctx, response.Entity.KAttributeId, value);
if (!res.IsValid)
{
response.ErrorList.Add(res.Message);
}
response.Entity.KAttributeValues.Add(res.Entity);
guidsUpdated.Add(value.KAttributeTabulatedValueId);
}
await DeleteNoContainsTabulateValueAsync(ctx, response.Entity.KAttributeId, guidsUpdated);
response.ErrorList = resGenRep.ErrorList;
}
}
else
{
response.Entity = entity;
response.AddErrorMessage("Can't find entity for update.");
}
scope.Complete();
await CloseIsTempConnection(ctx);
}
}
catch (Exception ex)
{
AddExecptionsMessagesToErrorsList(ex, response.ErrorList);
}
return(ResultDomainAction(response));
}
