private static InvalidBlocksService BuildBankInvalidServiceMock()
{
var mockResponse = new PaginatedResponseModel <BankInvalidBlock>()
{
Results = INVALID_BLOCK_TEST_DATA, Count = INVALID_BLOCK_TEST_DATA.Count
};
var requestSender = new Mock <IHttpRequestSender>();
var getAllResponse = new HttpResponseMessage(System.Net.HttpStatusCode.OK);
getAllResponse.Content = new StringContent(JsonConvert.SerializeObject(mockResponse), Encoding.UTF8, "application/json");
requestSender
.Setup(x => x.GetAsync(It.IsAny <string>()))
.Returns(Task.FromResult(getAllResponse));
var postResponse = new HttpResponseMessage(System.Net.HttpStatusCode.OK);
postResponse.Content = new StringContent(JsonConvert.SerializeObject(INVALID_BLOCK_TEST_DATA.First()), Encoding.UTF8, "application/json");
//TODO Setup for more Scenarios
requestSender
.Setup(x => x.PostAsync("/invalid_blocks", It.IsAny <StringContent>()))
.Returns(Task.FromResult(postResponse));
requestSender
.Setup(x => x.GetAsync(It.IsRegex(@"\/invalid_blocks\?offset=[0-9]*&limit=[0-9]*")))
.Returns(Task.FromResult(getAllResponse)); requestSender
.Setup(x => x.GetAsync("/invalid_blocks"))
.Returns(Task.FromResult(getAllResponse));
var invalidBlockService = new InvalidBlocksService(requestSender.Object);
return(invalidBlockService);
}
public async Task <PaginatedResponseModel <AppAuditLogDurationStatModel> > StatDurationAsync(DateTime startDate, DateTime endDate)
{
var sql = @"
select substr(logs.duration, 3) as duration, logs.request_count from (
select
case
when duration < 500 then '1: < 500ms'
when duration < 1000 then '2: 500ms ~ 1s'
when duration < 2000 then '3: 1s ~ 2s'
when duration < 5000 then '4: 2s ~ 5s'
when duration >= 5000 then '5: > 5s'
end as duration,
count(*) as request_count
from public.app_audit_logs
where (start_at >= @startDate and start_at < @endDate)
group by 1
) as logs
order by logs.duration;
";
var conn = Session.Connection;
var durations = await conn.QueryAsync <AppAuditLogDurationStatModel>(sql, new { startDate, endDate });
var result = new PaginatedResponseModel <AppAuditLogDurationStatModel> {
Data = durations.ToList()
};
return(result);
}
public async Task <PaginatedResponseModel <AppAuditLogTrafficStatModel> > StatTrafficAsync(DateTime startDate, DateTime endDate)
{
var sql = @"
with d as (
select generate_series(@startDate, @endDate, '1 day') as day
)
select
date_trunc('day', d.day) as request_date,
count(l.*) as request_count,
coalesce(avg(l.duration), 0) as avg_duration,
coalesce(max(l.duration), 0) as max_duration,
coalesce(min(l.duration), 0) as min_duration
from d
left join public.app_audit_logs l on l.start_at::date = d.day
group by d.day;
";
var conn = Session.Connection;
var trafics = await conn.QueryAsync <AppAuditLogTrafficStatModel>(
sql, new { startDate, endDate }
);
var result = new PaginatedResponseModel <AppAuditLogTrafficStatModel> {
Data = trafics.ToList()
};
return(result);
}
public ActionResult <PaginatedResponseModel <Message> > GetMessages([FromQuery] PaginationParams param, string by)
{
var userID = User.FindFirst(x => x.Type == "UserID").Value;
PaginatedResponse <Message> messages;
switch (by)
{
case "by":
{
messages = new PaginatedResponse <Message>(_messageService.GetAllSentByUser(userID).OrderByDescending(x => x.Sent), param.PageSize, param.PageIndex);
} break;
case "to":
{
messages = new PaginatedResponse <Message>(_messageService.GetAllSentToUser(userID).OrderByDescending(x => x.Sent), param.PageSize, param.PageIndex);
}
break;
default:
messages = new PaginatedResponse <Message>(_messageService.GetAllSentByUser(userID).OrderByDescending(x => x.Sent), param.PageSize, param.PageIndex);
break;
}
var response = new PaginatedResponseModel <Message>
{
Items = messages.GetResult(),
ResponseInfo = messages.GetResponseInfo()
};
return(response);
}
public async Task <ActionResult <PaginatedResponseModel <AppUserModel> > > GetAll(
[FromQuery] UserSearchRequestModel model
)
{
try {
IQueryable <AppUser> query;
if (string.IsNullOrEmpty(model.RoleName))
{
query = userMgr.Users;
}
else
{
var usersInRole = await userMgr.GetUsersInRoleAsync(model.RoleName);
query = usersInRole.AsQueryable();
}
if (model.UserName.IsNotNullOrEmpty())
{
query = query.Where(u => u.UserName.Contains(model.UserName));
}
var total = query.LongCount();
var sortInfo = model.SortBy.Split(
':',
StringSplitOptions.RemoveEmptyEntries
);
var propertyName = sortInfo[0];
var isAsc = sortInfo[1].Equals(
"ASC",
StringComparison.OrdinalIgnoreCase
);
var data = query
.AddOrderBy(sortInfo[0], isAsc)
.Skip(model.Skip)
.Take(model.Take)
.ToList();
var models = new List <AppUserModel>();
foreach (var user in data)
{
var claims = await userMgr.GetClaimsAsync(user);
var userModel = user.ToUserModel(mapper, claims);
models.Add(userModel);
}
var result = new PaginatedResponseModel <AppUserModel> {
Skip = model.Skip,
Take = model.Take,
Total = total,
Data = models
};
return(result);
}
catch (Exception ex) {
logger.LogError(ex, $"Can not search user with {model.ToJson()} .");
return(this.InternalServerError(ex));
}
}
public async void ListOfValidatorsIsReturned()
{
var expectedResponseModel = new PaginatedResponseModel <BankValidator>
{
Count = 2,
Next = null,
Previous = null,
Results =
new List <BankValidator>()
{
new BankValidator
{
AccountNumber = "ad1f8845c6a1abb6011a2a434a079a087c460657aad54329a84b406dce8bf314",
IpAddress = "192.168.1.74",
NodeIdentifier = "3afdf37573f1a511def0bd85553404b7091a76bcd79cdcebba1310527b167521",
Port = "8000",
Protocol = "http",
Version = "v1.0",
DefaultTransactionFee = 4,
RootAccountFile = "https://gist.githubusercontent.com/buckyroberts/519b5cb82a0a5b5d4ae8a2175b722520/raw/9237deb449e27cab93cb89ea3346ecdfc61fe9ea/0.json",
RootAccountFileHash = "4694e1ee1dcfd8ee5f989e59ae40a9f751812bf5ca52aca2766b322c4060672b",
SeedBlockIdentifier = "",
DailyConfirmationRate = "0",
Trust = "100.00"
},
new BankValidator
{
AccountNumber = "4d2ec91f37bc553bc538e91195669b666e26b2ea3e4e31507e38102a758d4f86",
IpAddress = "86.168.1.23",
NodeIdentifier = "59479a31c3b91d96bb7a0b3e07f18d4bf301f1bb0bde05f8d36d9611dcbe7cbf",
Port = "80",
Protocol = "http",
Version = "v1.0",
DefaultTransactionFee = 2,
RootAccountFile = "https://gist.githubusercontent.com/buckyroberts/519b5cb82a0a5b5d4ae8a2175b722520/raw/9237deb449e27cab93cb89ea3346ecdfc61fe9ea/0.json",
RootAccountFileHash = "4694e1ee1dcfd8ee5f989e59ae40a9f751812bf5ca52aca2766b322c4060672b",
SeedBlockIdentifier = "",
DailyConfirmationRate = "1",
Trust = "91.56"
}
}
};
var service = BuildBankValidatorMock(expectedResponseModel);
var validators = await service.GetAllValidatorsAsync();
var expectedResponseModelStr = JsonConvert.SerializeObject(expectedResponseModel);
var actualResponseModelStr = JsonConvert.SerializeObject(validators);
Assert.Equal(expectedResponseModelStr, actualResponseModelStr);
}
public async Task <PaginatedResponseModel <AppAuditLogStatusStatModel> > StatStatusAsync(DateTime startDate, DateTime endDate)
{
var query = Session.Query <AppAuditLog>()
.Where(log => log.StartAt <= startDate && log.StartAt < endDate)
.GroupBy(log => log.ResponseCode)
.Select(g => new AppAuditLogStatusStatModel {
StatusCode = g.Key,
RequestCount = g.Count()
}).OrderBy(x => x.StatusCode);
var result = new PaginatedResponseModel <AppAuditLogStatusStatModel> {
Data = await query.ToListAsync()
};
return(result);
}
public static IConnectedBanksService BuildGetBanksAsyncValidatorServiceMock(PaginatedResponseModel <ValidatorBank> expectedResponseModel)
{
var response = new HttpResponseMessage(HttpStatusCode.OK);
response.Content = new StringContent(JsonConvert.SerializeObject(expectedResponseModel), Encoding.UTF8, "application/json");
var requestSenderMock = new Mock <IHttpRequestSender>();
IConnectedBanksService service = new ConnectedBanksService(requestSenderMock.Object);
requestSenderMock
.Setup(x => x.GetAsync("/banks"))
.ReturnsAsync(response);
return(service);
}
public static IValidatorService BuildBankValidatorMock(PaginatedResponseModel <BankValidator> expectedResponseModel)
{
var requestSender = new Mock <IHttpRequestSender>();
var getAllResponse = new HttpResponseMessage(System.Net.HttpStatusCode.OK);
getAllResponse.Content = new StringContent(JsonConvert.SerializeObject(expectedResponseModel), Encoding.UTF8, "application/json");
requestSender
.Setup(x => x.GetAsync(It.IsAny <string>()))
.Returns(Task.FromResult(getAllResponse));
var validatorService = new ValidatorService(requestSender.Object);
return(validatorService);
}
public async Task <IActionResult> Get([FromQuery] int pageSize = 30, [FromQuery] int pageIndex = 0)
{
IEnumerable <VideoResponse> result = await VideoService.GetVideoAsync();
int totalItems = result.Count();
IEnumerable <VideoResponse> videosOnPage = result
.OrderBy(x => x.Title)
.Skip(pageSize * pageIndex)
.Take(pageSize);
PaginatedResponseModel <VideoResponse> model = new PaginatedResponseModel <VideoResponse>
(pageIndex, pageSize, totalItems, videosOnPage);
return(Ok(model));
}
public async Task <IActionResult> Get([FromQuery] int pageSize = 30, [FromQuery] int pageIndex = 0)
{
IEnumerable <GenreResponse> result = await GenreService.GetGenreAsync();
int totalItems = result.ToList().Count;
IEnumerable <GenreResponse> genresOnPage = result
.OrderBy(x => x.Name)
.Skip(pageSize * pageIndex)
.Take(pageSize);
PaginatedResponseModel <GenreResponse> model = new PaginatedResponseModel <GenreResponse>
(pageIndex, pageSize, totalItems, genresOnPage);
return(Ok(model));
}
public async void ListOfBanksIsReturned()
{
var expectedResponseModel = new PaginatedResponseModel <ValidatorBank>
{
Count = 2,
Next = null,
Previous = null,
Results =
new List <ValidatorBank>
{
new ValidatorBank
{
AccountNumber = "5e12967707909e62b2bb2036c209085a784fabbc3deccefee70052b6181c8ed8",
IpAddress = "83.168.1.232",
NodeIdentifier = "d5356888dc9303e44ce52b1e06c3165a7759b9df1e6a6dfbd33ee1c3df1ab4d1",
Port = 80,
Protocol = "http",
Version = "v1.0",
DefaultTransactionFee = 1,
ConfirmationExpiration = null,
Trust = "100.00"
},
new ValidatorBank
{
AccountNumber = "db1a9ac3c356ab744ab4ad5256bb86c2f6dfaa7c1aece1f026a08dbd8c7178f2",
IpAddress = "74.124.1.68",
NodeIdentifier = "3214108063cda7b259782c57ff8cec343ad2f1ad35baf38c3503db5cf6f3b2f7",
Port = 80,
Protocol = "http",
Version = "v1.0",
DefaultTransactionFee = 2,
ConfirmationExpiration = null,
Trust = "98.32"
}
}
};
var service = BuildGetBanksAsyncValidatorServiceMock(expectedResponseModel);
var banks = await service.GetBanksAsync();
var expectedResponseModelStr = JsonConvert.SerializeObject(expectedResponseModel);
var actualResponseModelStr = JsonConvert.SerializeObject(banks);
Assert.Equal(expectedResponseModelStr, actualResponseModelStr);
}
public async Task <ActionResult <PaginatedResponseModel <AppRoleModel> > > GetAll(
[FromQuery] AppRoleSearchModel model
)
{
try {
var data = await identityRepo.SearchAsync(model);
var result = new PaginatedResponseModel <AppRoleModel> {
Skip = model.Skip,
Take = model.Take,
Total = data.Count,
Data = data
};
return(result);
}
catch (Exception ex) {
logger.LogError(ex, $"Can not search roles with {model.ToJson()}");
return(this.InternalServerError(ex));
}
}
public async Task <PaginatedResponseModel <TodoItem> > GetAllTodoItems(GetAllTodoItemRequestModel request)
{
var response = new PaginatedResponseModel <TodoItem>();
try
{
if (request.Page <= 0)
{
response.Status = ResponseCodes.ValidationError;
response.Message = "Page must be a number greater than 0";
return(response);
}
if (request.PageSize <= 0)
{
response.Status = ResponseCodes.ValidationError;
response.Message = "Page size must be a number greater than 0";
return(response);
}
response.Data = await _todoItemProvider.GetAllTodoItemsAsync(request);
response.Status = ResponseCodes.Success;
response.Message = "Success";
return(response);
}
catch (Exception e)
{
response.Status = ResponseCodes.ProcessError;
var logMessage = response.Message = "Failed to get todo items.";
_logger.LogError(e, logMessage + " | Request: {@0}", request);
return(response);
}
}
