public object GetAllStudent(Pager page) { var records = _studentRepository.Queryable().AsNoTracking(). Select(p => new { p.StudentId, p.Name, p.Age, DateCreated = p.dateCreated, DateModified = p.dateModified }); if (page.Keyword.HasValue()) { records = records.Where(p => p.Name.Contains(page.Keyword)); } GetAllResponse response = null; int maxRecord = 10; if (page.ShowAll == false) { response = new GetAllResponse(records.Count(), page.CurrentPage, maxRecord); records = records.Skip((page.CurrentPage - 1) * maxRecord); } else { response = new GetAllResponse(records.Count()); } response.List.AddRange(records); return(response); }
public async Task <GetAllResponse> GetAll() { try { var result = new GetAllResponse(); var entities = await _appointmentRepository.ListAll(); if (entities.Any()) { foreach (var entity in entities) { result.Add(new CreateAppointmentResponse { Id = entity.Id, EndDateTime = entity.EndDateTime, Invitee = entity.Invitee, StartDateTime = entity.StartDateTime, Length = entity.Length, Name = entity.Name, Owner = entity.Owner }); } } return(result); } catch (Exception exception) { _logger.LogError(exception, $"{nameof(GetAll)} appoinments error occured"); throw; } }
private List <Response> processGetAll(string data) { List <Response> responses = new List <Response>(); MatchCollection keys = KEY_PATTERN.Matches(data); MatchCollection values = VALUE_PATTERN.Matches(data); for (int i = 0; i < keys.Count; i++) { //uhhhh wat? Match key = keys[i]; Match value = values[i]; GetAllResponse resp = new GetAllResponse(); resp.key = key.ToString(); resp.key = resp.key.Substring(resp.key.IndexOf(": \"") + 3).Trim('\"'); resp.value = value.ToString(); resp.value = resp.value.Substring(resp.value.IndexOf(": \"") + 3).Trim('\"'); resp.timestamp = Stopwatch.GetTimestamp(); if (enableDebug) { Debug.Log($"[SocketTables][Core] Response Key : \"{resp.key}\" Value : \"{resp.value}\""); } responses.Add(resp); } return(responses); }
/// <summary> /// Retrieves and removes all tuples from the space matching the specified pattern. The operation is non-blocking. The operation will return an empty set if no elements match. /// </summary> public IEnumerable <ITuple> GetAll(params object[] pattern) { GetAllRequest request = new GetAllRequest(this.GetSource(), this.GetSessionId(), this.connectionString.Target, pattern); GetAllResponse response = this.GetMode()?.PerformRequest <GetAllResponse>(request); return(response.Result == null ? null : response.Result.Select(x => this.tupleFactory.Create(x))); }
public override Task <GetAllResponse> GetAll(GetAllRequest request, ServerCallContext context) { var result = new GetAllResponse(); result.Employees.AddRange(_employeeRepository.GetAll()); return(Task.FromResult(result)); }
public Task <GetAllResponse> GetAll() { var response = new GetAllResponse(); response.Data = _repoUser.GetAll().Select(x => AutoMapper.Map <SysUser, UserDto>(x)); return(Task.FromResult(response)); }
/// <inheritdoc /> public override Task <GetAllResponse> GetAll(GetAllRequest request, ServerCallContext context) { Log.GetAll(_logger); var response = new GetAllResponse(); response.EventHandlers.AddRange(_eventHandlers.All.Select(_ => CreateStatusFromInfo(_, request.TenantId?.ToGuid()))); return(Task.FromResult(response)); }
public override async Task <GetAllResponse> GetAll(GetAllRequest request, ServerCallContext context) { var today = await _repository.GetEventsFromFileAsync(); var response = new GetAllResponse(); response.TodayEvents.AddRange(today.TodayEventList.Select(TodayEvent.FromRepositoryModel)); return(response); }
public override async Task <GetAllResponse> GetAll(Empty request, ServerCallContext context) { var response = new GetAllResponse(); var users = await _userRepository.GetAll(); response.Users.AddRange(_mapper.Map <IEnumerable <User> >(users)); return(response); }
public override async Task <GetAllResponse> GetAll(GetAllRequest request, ServerCallContext context) { var traderId = ValidateUser(request.TraderId, context); var portfolios = await _repository.GetAllAsync(traderId); var response = new GetAllResponse(); response.Portfolios.AddRange(portfolios.Select(Protos.Portfolio.FromRepositoryModel)); return(response); }
public override async Task <GetAllResponse> GetAll(GetAllRequest request, ServerCallContext context) { var result = await _notificationService.GetAllNotifications(); var response = new GetAllResponse(); response.Notifications.AddRange(result.Select(n => new Notification() { Message = n.Message })); return(response); }
public override async Task <GetAllResponse> GetAll(GetAllRequest request, ServerCallContext context) { if (!Guid.TryParse(request.TraderId, out var traderId)) { throw new RpcException(new Status(StatusCode.InvalidArgument, "traderId must be a UUID")); } var portfolios = await _portfolioRepository.GetAllAsync(traderId); var response = new GetAllResponse(); response.Portfolios.AddRange(portfolios.Select(Protos.Portfolio.FromRepositoryModel)); return(response); }
public override async Task <GetAllResponse> GetAll(Empty request, ServerCallContext context) { var classes = await _client.GetAllClassesAsync(); var result = new GetAllResponse(); result.Data.AddRange(classes.Results.Select(c => new GetAllResponse.Types.ClassArchiveItem() { Id = c.Index, Name = c.Name })); return(result); }
public virtual GetAllResponse <TDto> GetAll(GetAllRequest request) { var response = new GetAllResponse <TDto> { IsSuccess = false, ItemList = null }; try { var results = new List <TDto>(); var models = _repository.GetAll(request); if (models.Any()) { foreach (var model in models) { results.Add(MapToDto(model)); } response.ItemList = results; response.IsSuccess = true; return(response); } response.ErrorMessage = "Search yielded no results."; response.ItemList = new List <TDto>(); return(response); } catch (DbEntityValidationException dbx) { // Retrieve the error messages as a list of strings. var errorMessages = dbx.EntityValidationErrors .SelectMany(x => x.ValidationErrors) .Select(x => x.ErrorMessage); // Join the list to a single string. var fullErrorMessage = string.Join("; ", errorMessages); // Combine the original exception message with the new one. var exceptionMessage = string.Concat(dbx.Message, " The validation errors are: ", fullErrorMessage); // Throw a new DbEntityValidationException with the improved exception message. throw new System.Exception(exceptionMessage); } catch (System.Exception ex) { ErrorHandler.LogException(ex); response.ErrorMessage = ErrorsEnum.ExceptionEncountered.FriendlyErrorMessage(); response.IsSuccess = false; response.ErrorCode = (int)ErrorsEnum.ExceptionEncountered; return(response); } }
public GetAllResponse <CategoryDto> Execute(GetAll search) { var categories = context.Categories.AsQueryable(); var reponse = new GetAllResponse <CategoryDto> { Items = categories.Select(x => new CategoryDto { Id = x.Id, Name = x.Name }).ToList() }; return(reponse); }
public IEnumerable <Excursie> GetAllE() { sendRequest(new GetAllRequest()); Response res = readResponse(); if (res is ErrorResponse) { ErrorResponse err = (ErrorResponse)res; throw new Exception(err.Message); } GetAllResponse resp = (GetAllResponse)res; ExcursieDTO meciuriDTO = resp.Excursie; return(meciuriDTO.getExc()); }
public GetAllResponse <AuthorDto> Execute(GetAll search) { var authors = context.Authors.AsQueryable(); var reponse = new GetAllResponse <AuthorDto> { Items = authors.Select(x => new AuthorDto { Id = x.Id, FirstName = x.FirstName, LastName = x.LastName }).ToList() }; return(reponse); }
public GetAllResponse <CartDto> Execute(GetAll search) { var CartItems = context.Carts.AsQueryable(); var reponse = new GetAllResponse <CartDto> { Items = CartItems.Select(x => new CartDto { Id = x.Id, Quanity = x.CartItems.Select(c => c.Quantity).FirstOrDefault(), Book = x.CartItems.Select(c => c.Book).FirstOrDefault() }).ToList() }; return(reponse); }
public GetAllResponse <PublisherDto> Execute(GetAll search) { var publishers = context.Publishers.AsQueryable(); var reponse = new GetAllResponse <PublisherDto> { Items = publishers.Select(x => new PublisherDto { Id = x.Id, Name = x.Name, Address = x.Address }).ToList() }; return(reponse); }
static Task SendBatch(GetAllRequest request, GetAllResponse batchToSend, IServerStreamWriter <GetAllResponse> responseStream, ILogger logger) { if (batchToSend.States.Count == 1 && batchToSend.CalculateSize() > MaxBatchMessageSize) { var stateThatIsTooLarge = batchToSend.States[0]; Log.ProjectionStateTooLargeButSendingAnyways( logger, stateThatIsTooLarge.Key, request.ProjectionId, request.ScopeId, stateThatIsTooLarge.CalculateSize(), MaxBatchMessageSize); } Log.SendingGetAllInBatchesResult(logger, request.ProjectionId, request.ScopeId, batchToSend.States.Count); return(responseStream.WriteAsync(batchToSend)); }
public async Task <IActionResult> GetAll(GetAllRequest request) { var getAllResult = await _projectionsService.TryGetAll( request.Projection, request.Scope, request.Context.ExecutionContext.ToExecutionContext(), System.Threading.CancellationToken.None).ConfigureAwait(false); if (getAllResult.Success) { var states = await getAllResult.Result.ToListAsync(); return(Ok(GetAllResponse.From(states))); } Response.StatusCode = StatusCodes.Status500InternalServerError; return(new JsonResult(GetAllResponse.From(getAllResult.Exception.ToFailure()))); }
public async Task <PersistenceResponse <GetAllResponse <TEntity> > > GetAll() { try { var all = await _database.Set <TEntity>().Where(e => !e.IsDeleted).ToListAsync(); var getAllResponse = new GetAllResponse <TEntity> { Items = all, TotalCount = all.Count }; return(PersistenceResponseStatus.Success.GetSuccessResponse(getAllResponse)); } catch (Exception e) { Console.WriteLine(e); return(PersistenceResponseStatus.PersistenceFailure.GetFailureResponse <PersistenceResponseStatus, GetAllResponse <TEntity> >(e.InnerException != null ? e.Message + "\n" + e.InnerException.Message : e.Message)); } }
public static GetAllResponse GetAll(GetFAQRequest request) { GetAllResponse response = new GetAllResponse(); try { using (FAQDao dao = new FAQDao()) { MFaq[] faqs = dao.GetFaqs(request.page_number, request.row_per_page); if (faqs.Length > 0) { FAQDto[] faqDtos = new FAQDto[faqs.Length]; for (int i = 0; i < faqs.Length; i++) { FAQDto dto = new FAQDto(); dto.faq_id = faqs[i].FaqID; dto.question = faqs[i].Question; dto.answer = faqs[i].Answer; faqDtos[i] = dto; } response.faq_list = faqDtos; response.code = 0; response.has_resource = 1; response.message = MessagesSource.GetMessage("faq.list"); return(response); } else { response.code = 0; response.has_resource = 0; response.message = MessagesSource.GetMessage("faq.list.not.found"); } } } catch (Exception ex) { response.MakeExceptionResponse(ex); } return(response); }
/// <inheritdoc /> public override async Task GetAllInBatches(GetAllRequest request, IServerStreamWriter <GetAllResponse> responseStream, ServerCallContext context) { var getAllResult = await _projectionsService.TryGetAll( request.ProjectionId.ToGuid(), request.ScopeId.ToGuid(), request.CallContext.ExecutionContext.ToExecutionContext(), context.CancellationToken).ConfigureAwait(false); if (!getAllResult.Success) { Log.SendingGetAllInBatchesFailed(_logger, request.ProjectionId, request.ScopeId, getAllResult.Exception); var response = new GetAllResponse { Failure = getAllResult.Exception.ToFailure() }; await responseStream.WriteAsync(response).ConfigureAwait(false); return; } var statesEnumerator = getAllResult.Result.GetAsyncEnumerator(context.CancellationToken); try { var hasMoreStates = await statesEnumerator.MoveNextAsync().ConfigureAwait(false); while (hasMoreStates) { var batchToSend = new GetAllResponse(); batchToSend.States.Add(statesEnumerator.Current.ToProtobuf()); hasMoreStates = await FillBatch(statesEnumerator, batchToSend).ConfigureAwait(false); await SendBatch(request, batchToSend, responseStream, _logger).ConfigureAwait(false); } } finally { await statesEnumerator.DisposeAsync().ConfigureAwait(false); } }
public object GetAll(GetAll criteria, AppSettings appSettings) { var records = _context.Users.AsNoTracking() .Select(p => new { p.Id, p.FullName, p.UserName }); GetAllResponse response = null; // Check if user don't want to show all records if (criteria.ShowAll == false) { response = new GetAllResponse(records.Count(), criteria.CurrentPage, appSettings.RecordDisplayPerPage); // Check if CurrentPage is greater than TotalPage if (criteria.CurrentPage > response.TotalPage) { var error = new ErrorResponse(); error.ErrorMessages.Add(MessageHelper.NoRecordFound); // Return no record found error return(error); } records = records.Skip((criteria.CurrentPage - 1) * appSettings.RecordDisplayPerPage) .Take(appSettings.RecordDisplayPerPage); } else { response = new GetAllResponse(records.Count()); } response.List.AddRange(records); return(response); }
public async Task <PersistenceResponse <GetAllResponse <TEntity> > > GetAll(Func <TEntity, bool> whereExpression) { try { var all = whereExpression != null ? _database.Set <TEntity>().Where(e => !e.IsDeleted).AsEnumerable().Where(whereExpression).ToList() : await _database.Set <TEntity>().Where(e => !e.IsDeleted).ToListAsync(); var getAllResponse = new GetAllResponse <TEntity> { Items = all, TotalCount = all.Count }; return(PersistenceResponseStatus.Success.GetSuccessResponse(getAllResponse)); } catch (Exception e) { Console.WriteLine(e); return(PersistenceResponseStatus.PersistenceFailure.GetFailureResponse <PersistenceResponseStatus, GetAllResponse <TEntity> >(e.Message)); } }
public GetAllResponse <LogDto> Execute(LogSearch search) { var query = context.UseCaseLogs.AsQueryable(); if (search.StartDate != null || search.EndDate != null) { query = query.Where(obj => obj.Date >= search.StartDate && obj.Date <= search.EndDate); } var reponse = new GetAllResponse <LogDto> { Items = query.Select(log => new LogDto { Actor = log.Actor, Data = log.Data, Date = log.Date, UseCaseName = log.UseCaseName }) }; return(reponse); }
public static async Task <ApiResponse <GetAllResponse <TOutput> > > GetUseCaseInteractorResponse <TEntity, TOutput>(Func <Task <UseCaseResult <GetAllResponse <TEntity> > > > useCase) where TOutput : class { var useCaseResponse = await useCase(); if (!useCaseResponse.Success) { return(Failure <GetAllResponse <TOutput> >(useCaseResponse.Message)); } var outputs = new GetAllResponse <TOutput> { Items = new List <TOutput>() }; foreach (var output in useCaseResponse.Result.Items.Select(entity => Activator.CreateInstance(typeof(TOutput), entity) as TOutput)) { outputs.Items.Add(output); } outputs.TotalCount = useCaseResponse.Result.TotalCount; return(Success(outputs, useCaseResponse.Message)); }
/// <inheritdoc /> public override async Task <GetAllResponse> GetAll(GetAllRequest request, ServerCallContext context) { try { _logger.GetAllAggregateRoots(); var response = new GetAllResponse(); var tenant = request.TenantId?.ToGuid(); var aggregatesRoots = tenant is null ? await _tenantScopedAggregateRoot.GetAllAggregateRootsForAllTenants().ConfigureAwait(false) : await _tenantScopedAggregateRoot.GetAllAggregateRootsFor(tenant).ConfigureAwait(false); response.AggregateRoots.AddRange(aggregatesRoots.Select(ToProtobuf)); return(response); } catch (Exception ex) { _logger.Failure(ex); return(new GetAllResponse { Failure = ex.ToProtobuf() }); } }
/// <inheritdoc/> public override async Task <GetAllResponse> GetAll(GetAllRequest request, ServerCallContext context) { var response = new GetAllResponse(); var getAllResult = await _projectionsService.TryGetAll( request.ProjectionId.ToGuid(), request.ScopeId.ToGuid(), request.CallContext.ExecutionContext.ToExecutionContext(), context.CancellationToken).ConfigureAwait(false); if (getAllResult.Success) { var states = await getAllResult.Result.ToListAsync(context.CancellationToken).ConfigureAwait(false); response.States.AddRange(states.ToProtobuf()); Log.SendingGetAllResult(_logger, request.ProjectionId, request.ScopeId, response.States.Count); } else { response.Failure = getAllResult.Exception.ToFailure(); Log.SendingGetAllFailed(_logger, request.ProjectionId, request.ScopeId, getAllResult.Exception); } return(response); }