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); }