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