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 <NoteTypeDto> > AddAsync(NoteTypeDto entity)
{
var response = new Result <NoteTypeDto>();
try
{
var ctx = GetOpenConnection();
var noteTypes = new GenericRepositoryEF <KntDbContext, NoteType>(ctx);
var newEntity = new NoteType();
newEntity.SetSimpleDto(entity);
var resGenRep = await noteTypes.AddAsync(newEntity);
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 <List <KAttributeInfoDto> > > GetAllAsync()
{
var resService = new Result <List <KAttributeInfoDto> >();
try
{
var ctx = GetOpenConnection();
var kattributes = new GenericRepositoryEF <KntDbContext, KAttribute>(ctx);
var listAtr = await kattributes.DbSet
.Include(a => a.NoteType)
.OrderBy(a => a.Order).ThenBy(a => a.Name)
.ToListAsync();
List <KAttributeInfoDto> listDto = new List <KAttributeInfoDto>();
foreach (var a in listAtr)
{
var dto = a.GetSimpleDto <KAttributeInfoDto>();
dto.NoteTypeDto = a.NoteType?.GetSimpleDto <NoteTypeDto>();
listDto.Add(dto);
}
resService.Entity = listDto;
await CloseIsTempConnection(ctx);
}
catch (Exception ex)
{
AddExecptionsMessagesToErrorsList(ex, resService.ErrorList);
}
return(ResultDomainAction(resService));
}
public async Task <Result <UserInternalDto> > AddInternalAsync(UserInternalDto entity)
{
var resService = new Result <UserInternalDto>();
try
{
var ctx = GetOpenConnection();
var users = new GenericRepositoryEF <KntDbContext, User>(ctx);
var newEntity = entity.GetSimpleDto <User>();
var resRep = await users.AddAsync(newEntity);
resService.Entity = resRep.Entity?.GetSimpleDto <UserInternalDto>();
resService.ErrorList = resRep.ErrorList;
await CloseIsTempConnection(ctx);
}
catch (Exception ex)
{
AddExecptionsMessagesToErrorsList(ex, resService.ErrorList);
}
return(ResultDomainAction(resService));
}
public async Task <Result <List <KAttributeTabulatedValueDto> > > GetKAttributeTabulatedValuesAsync(Guid attributeId)
{
var result = new Result <List <KAttributeTabulatedValueDto> >();
try
{
var ctx = GetOpenConnection();
var kattributeTabulatedValues = new GenericRepositoryEF <KntDbContext, KAttributeTabulatedValue>(ctx);
var resRep = await kattributeTabulatedValues.GetAllAsync(tv => tv.KAttributeId == attributeId);
if (resRep.IsValid)
{
result.Entity = resRep.Entity.Select(_ => _.GetSimpleDto <KAttributeTabulatedValueDto>()).OrderBy(_ => _.Order).ToList();
}
else
{
result.ErrorList = resRep.ErrorList;
}
await CloseIsTempConnection(ctx);
}
catch (Exception ex)
{
AddExecptionsMessagesToErrorsList(ex, result.ErrorList);
}
return(ResultDomainAction(result));
}
public async Task <Result <FolderDto> > AddAsync(FolderDto entity)
{
var response = new Result <FolderDto>();
try
{
var ctx = GetOpenConnection();
var folders = new GenericRepositoryEF <KntDbContext, Folder>(ctx);
var newEntity = new Folder();
newEntity.SetSimpleDto(entity);
newEntity.FolderNumber = GetNextFolderNumber(folders);
newEntity.CreationDateTime = DateTime.Now;
newEntity.ModificationDateTime = DateTime.Now;
var resGenRep = await folders.AddAsync(newEntity);
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 <FolderDto> > GetHomeAsync()
{
var resService = new Result <FolderDto>();
try
{
var ctx = GetOpenConnection();
var folders = new GenericRepositoryEF <KntDbContext, Folder>(ctx);
var homeFolder = await folders.DbSet
.Where(f => f.FolderNumber == 1)
.Select(f => f)
.FirstOrDefaultAsync();
resService.Entity = homeFolder.GetSimpleDto <FolderDto>();
await CloseIsTempConnection(ctx);
}
catch (Exception ex)
{
AddExecptionsMessagesToErrorsList(ex, resService.ErrorList);
}
return(ResultDomainAction(resService));
}
public async Task <Result <List <NoteTypeDto> > > GetAllAsync()
{
var response = new Result <List <NoteTypeDto> >();
try
{
var ctx = GetOpenConnection();
var noteTypes = new GenericRepositoryEF <KntDbContext, NoteType>(ctx);
var resGenRep = await noteTypes.GetAllAsync();
response.Entity = resGenRep.Entity?
.Select(t => t.GetSimpleDto <NoteTypeDto>())
.OrderBy(t => t.Name)
.ToList();
response.ErrorList = resGenRep.ErrorList;
await CloseIsTempConnection(ctx);
}
catch (Exception ex)
{
AddExecptionsMessagesToErrorsList(ex, response.ErrorList);
}
return(ResultDomainAction(response));
}
public async Task <Result <List <KAttributeInfoDto> > > GetAllIncludeNullTypeAsync(Guid?typeId)
{
var resService = new Result <List <KAttributeInfoDto> >();
try
{
// TODO: pendiente de poblar la propiedad NoteTypeDto. Coger implementación de GetAllAsync().
var ctx = GetOpenConnection();
var kattributes = new GenericRepositoryEF <KntDbContext, KAttribute>(ctx);
var resRep = await kattributes.GetAllAsync(_ => _.NoteTypeId == null || _.NoteTypeId == typeId);
resService.Entity = resRep.Entity?
.Select(a => a.GetSimpleDto <KAttributeInfoDto>())
.OrderBy(a => a.Order).ThenBy(a => a.Name)
.ToList();
resService.ErrorList = resRep.ErrorList;
await CloseIsTempConnection(ctx);
}
catch (Exception ex)
{
AddExecptionsMessagesToErrorsList(ex, resService.ErrorList);
}
return(ResultDomainAction(resService));
}
private int GetNextFolderNumber(GenericRepositoryEF <KntDbContext, Folder> folders)
{
// Emplear método LastOrDefault() en lugar de FirstOrDafault
var lastFolder = folders
.DbSet.OrderByDescending(f => f.FolderNumber).FirstOrDefault();
return(lastFolder != null ? lastFolder.FolderNumber + 1 : 1);
}
public async Task <Result <int> > GetNextFolderNumber()
{
var result = new Result <int>();
try
{
var ctx = GetOpenConnection();
var folders = new GenericRepositoryEF <KntDbContext, Folder>(ctx);
result.Entity = GetNextFolderNumber(folders);
await CloseIsTempConnection(ctx);
}
catch (Exception ex)
{
AddExecptionsMessagesToErrorsList(ex, result.ErrorList);
}
return(ResultDomainAction(result));
}
private async Task <Result <KAttributeTabulatedValueDto> > SaveTabulateValueAsync(KntDbContext ctx, Guid attributeId, KAttributeTabulatedValueDto entity)
{
Result <KAttributeTabulatedValue> resRep = null;
var resService = new Result <KAttributeTabulatedValueDto>();
try
{
var kattributeTabulatedValues = new GenericRepositoryEF <KntDbContext, KAttributeTabulatedValue>(ctx);
if (entity.KAttributeTabulatedValueId == Guid.Empty)
{
entity.KAttributeTabulatedValueId = Guid.NewGuid();
var newEntity = new KAttributeTabulatedValue();
newEntity.SetSimpleDto(entity);
newEntity.KAttributeId = attributeId;
resRep = await kattributeTabulatedValues.AddAsync(newEntity);
}
else
{
var entityForUpdate = kattributeTabulatedValues.Get(entity.KAttributeTabulatedValueId).Entity;
if (entityForUpdate != null)
{
entityForUpdate.SetSimpleDto(entity);
resRep = await kattributeTabulatedValues.UpdateAsync(entityForUpdate);
}
else
{
var newEntity = new KAttributeTabulatedValue();
newEntity.SetSimpleDto(entity);
newEntity.KAttributeId = attributeId;
resRep = await kattributeTabulatedValues.AddAsync(newEntity);
}
}
}
catch (Exception ex)
{
AddExecptionsMessagesToErrorsList(ex, resService.ErrorList);
}
resService.Entity = resRep.Entity?.GetSimpleDto <KAttributeTabulatedValueDto>();
resService.ErrorList = resRep.ErrorList;
return(ResultDomainAction(resService));
}
public async Task <Result <long> > GetCount()
{
var resService = new Result <long>();
try
{
var ctx = GetOpenConnection();
var users = new GenericRepositoryEF <KntDbContext, User>(ctx);
resService.Entity = await users.Queryable.CountAsync();
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 <KAttributeDto> > AddAsync(KAttributeDto entity)
{
var response = new Result <KAttributeDto>();
try
{
using (TransactionScope scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
var ctx = GetOpenConnection();
var kattributes = new GenericRepositoryEF <KntDbContext, KAttribute>(ctx);
var newEntity = new KAttribute();
newEntity.SetSimpleDto(entity);
var resGenRep = await kattributes.AddAsync(newEntity);
response.Entity = resGenRep.Entity?.GetSimpleDto <KAttributeDto>();
response.ErrorList = resGenRep.ErrorList;
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);
}
scope.Complete();
await CloseIsTempConnection(ctx);
}
}
catch (Exception ex)
{
AddExecptionsMessagesToErrorsList(ex, response.ErrorList);
}
return(ResultDomainAction(response));
}
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 <List <FolderInfoDto> > > GetAllAsync()
{
var resService = new Result <List <FolderInfoDto> >();
try
{
var ctx = GetOpenConnection();
var folders = new GenericRepositoryEF <KntDbContext, Folder>(ctx);
var resRep = await folders.GetAllAsync();
resService.Entity = resRep.Entity?.Select(f => f.GetSimpleDto <FolderInfoDto>()).ToList();
resService.ErrorList = resRep.ErrorList;
await CloseIsTempConnection(ctx);
}
catch (Exception ex)
{
AddExecptionsMessagesToErrorsList(ex, resService.ErrorList);
}
return(ResultDomainAction(resService));
}
public async Task <Result <SystemValueDto> > GetAsync(Guid id)
{
var resService = new Result <SystemValueDto>();
try
{
var ctx = GetOpenConnection();
var systemValues = new GenericRepositoryEF <KntDbContext, SystemValue>(ctx);
var resRep = await systemValues.GetAsync((object)id);
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 <List <FolderDto> > > GetTreeAsync(Guid?parentId = null)
{
var result = new Result <List <FolderDto> >();
var treeFolders = new List <FolderDto>();
try
{
var ctx = GetOpenConnection();
var folders = new GenericRepositoryEF <KntDbContext, Folder>(ctx);
var allFolders = await folders.DbSet.ToListAsync();
var allFoldersInfo = allFolders.Select(f => f.GetSimpleDto <FolderDto>()).ToList();
treeFolders = allFoldersInfo.Where(fi => fi.ParentId == parentId)
.OrderBy(f => f.Order).ThenBy(f => f.Name).ToList();
foreach (FolderDto f in treeFolders)
{
LoadChilds(f, allFoldersInfo);
}
result.Entity = treeFolders;
await CloseIsTempConnection(ctx);
}
catch (KntEntityValidationException ex)
{
AddDBEntityErrorsToErrorsList(ex, result.ErrorList);
}
catch (Exception ex)
{
AddExecptionsMessagesToErrorsList(ex, result.ErrorList);
}
return(ResultDomainAction <List <FolderDto> >(result));
}
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> > GetByUserNameAsync(string userName)
{
var resService = new Result <UserDto>();
try
{
var ctx = GetOpenConnection();
var users = new GenericRepositoryEF <KntDbContext, User>(ctx);
var resRep = await users.GetAsync(_ => _.UserName == userName);
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 <List <UserDto> > > GetAllAsync(PageIdentifier pagination = null)
{
var resService = new Result <List <UserDto> >();
try
{
var ctx = GetOpenConnection();
var users = new GenericRepositoryEF <KntDbContext, User>(ctx);
if (pagination != null)
{
var query = users.Queryable
.OrderBy(u => u.UserName)
.Pagination(pagination);
resService.Entity = await query
.Select(u => u.GetSimpleDto <UserDto>())
.ToListAsync();
}
else
{
var query = users.Queryable
.OrderBy(u => u.UserName);
resService.Entity = await query
.Select(u => u.GetSimpleDto <UserDto>())
.ToListAsync();
}
resService.TotalCount = (await GetCount()).Entity;
await CloseIsTempConnection(ctx);
}
catch (Exception ex)
{
AddExecptionsMessagesToErrorsList(ex, resService.ErrorList);
}
return(ResultDomainAction(resService));
}
public async Task <Result> DeleteAsync(Guid id)
{
var response = new Result();
try
{
var ctx = GetOpenConnection();
var noteTypes = new GenericRepositoryEF <KntDbContext, NoteType>(ctx);
var resGenRep = await noteTypes.DeleteAsync(id);
if (!resGenRep.IsValid)
{
response.ErrorList = resGenRep.ErrorList;
}
await CloseIsTempConnection(ctx);
}
catch (Exception ex)
{
AddExecptionsMessagesToErrorsList(ex, response.ErrorList);
}
return(ResultDomainAction(response));
}
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));
}
private async Task DeleteNoContainsTabulateValueAsync(KntDbContext ctx, Guid attributeId, List <Guid> guids)
{
var kattributeTabulatedValues = new GenericRepositoryEF <KntDbContext, KAttributeTabulatedValue>(ctx);
var tabValuesForDelete = (await kattributeTabulatedValues.GetAllAsync(v => (v.KAttributeId == attributeId && !guids.Contains(v.KAttributeTabulatedValueId)))).Entity;
var res = kattributeTabulatedValues.DeleteRange(tabValuesForDelete);
}
