public virtual async Task <IActionResult> GetAsync(QueryString queryString)
{
var query = Repository.Query.AsNoTracking();
query = ApplyRouteParams(query);
query = QueryBuilder.Build(query, queryString);
var entityList = await PagedList <TEntity> .CreateAsync(query, queryString);
if (!entityList.Any())
{
await ValidateRouteAsync(queryString);
if (ResponseBuilder.HasErrors())
{
return(NotFound(ResponseBuilder.Build()));
}
}
Response.Headers.Add("X-Paging", PagingHeaderBuilder.Build(this, queryString, entityList));
var data = ApiMapper.Map <IEnumerable <TOutDto> >(entityList).Select(p => Shaper.Shape(p, queryString));
LogData(data);
return(Ok(ResponseBuilder
.AddData(data)
.Build()));
}
public async Task <ActionResult <ApiAssignSeatsResponse> > AssignSeats([FromBody] ApiAssignSeatsRequest request)
{
var mapper = new ApiMapper(request);
var response = await findSolution.Execute(mapper.GetDomainRequest());
return(mapper.GetApiResponse(response, "/"));
}
public virtual async Task <IActionResult> PutAsync(TKey id, [FromBody] TInDto dto, QueryString queryString)
{
LogData(dto);
var query = Repository.Query.Where(p => p.Id.Equals(id));
query = ApplyRouteParams(query);
var entity = await query.FirstOrDefaultAsync();
if (entity == null)
{
return(await BuildResponseForNotFoundEntityAsync(id, queryString));
}
ApiMapper.Map(dto, entity);
var result = await UpdateFlowAsync(dto, entity, SaveAsync);
if (result != null)
{
return(result);
}
return(NoContent());
}
public async Task <IActionResult> PutUsers(int id, ApiUsers users)
{
if (id != users.UserId)
{
return(BadRequest("User does not exist."));
}
var resource = ApiMapper.MapUsers(users);
try
{
await _repo.UpdateUserAsync(resource);
}
catch (DbUpdateConcurrencyException)
{
if (!await _repo.UserExistAsync(id))
{
return(NotFound("User not found."));
}
else
{
throw;
}
}
return(Ok("User updated."));
}
public virtual async Task <IActionResult> PostBatchAsync([FromBody] IEnumerable <TInDto> dtoList)
{
LogData(dtoList);
await ValidateRouteAsync(forceValidation : true);
if (ResponseBuilder.HasErrors())
{
return(NotFound(ResponseBuilder.Build()));
}
var entityList = ApiMapper.Map <IEnumerable <TEntity> >(dtoList);
Repository.AddRange(entityList);
var result = await PostFlowAsync(dtoList, entityList, SaveAsync);
if (result != null)
{
return(result);
}
var outDtoList = ApiMapper.Map <IEnumerable <TOutDto> >(entityList);
var ids = string.Join(',', outDtoList.Select(p => p.Id));
LogData(outDtoList);
return(CreatedAtAction(nameof(GetBatchAsync), new { ids }, ResponseBuilder
.AddData(outDtoList)
.Build()));
}
protected override void Load(ContainerBuilder builder)
{
base.Load(builder);
RegistrationBuilders = new List <IRegistrationBuilder <object, object, object> >
{
builder.Register(c => new AppSettings
{
AuthSecret = _securityKey,
AccessTokenExpirtionTime = _accessTokenExpireMins,
RefreshTokenExpirationDays = _refreshTokenExpireDays,
WorkFactorComplexity = _hashingComplexity
}).AsSelf(),
builder.Register(c => new ApiMapper(ApiMapper.GetMapperConfiguration().CreateMapper())).As <IApiMapper>(),
builder.RegisterType <TokenService>().As <ITokenService>(),
builder.RegisterType <BookingService>().As <IBookingService>(),
builder.RegisterType <AccountService>().As <IAccountService>(),
builder.RegisterType <FileService>().As <IFileService>(),
builder.RegisterType <ClinicService>().As <IClinicService>(),
builder.RegisterType <ClinicianService>().As <IClinicianService>(),
builder.RegisterType <DocumentService>().As <IDocumentService>(),
builder.RegisterType <ClinicClinicianService>().As <IClinicClinicianService>()
};
SetDependenciesInstanceType();
}
public virtual async Task <IActionResult> PostAsync([FromBody] TInDto dto)
{
LogData(dto);
await ValidateRouteAsync(forceValidation : true);
if (ResponseBuilder.HasErrors())
{
return(NotFound(ResponseBuilder.Build()));
}
var entity = ApiMapper.Map <TEntity>(dto);
Repository.Add(entity);
var result = await PostFlowAsync(dto, entity, SaveAsync);
if (result != null)
{
return(result);
}
var data = ApiMapper.Map <TOutDto>(entity);
LogData(data);
return(CreatedAtAction(nameof(GetAsync), new { id = entity.Id }, ResponseBuilder
.AddData(data)
.Build()));
}
public async Task <IActionResult> PutCreditUnion(int id, ApiCreditUnion creditUnion)
{
if (id != creditUnion.UnionId)
{
return(BadRequest("Credit Union does not exist."));
}
var resource = ApiMapper.MapUnion(creditUnion);
try
{
await _repo.UpdateCreditUnionAsync(resource);
}
catch (DbUpdateConcurrencyException)
{
if (!await _repo.CreditUnionExistAsync(id))
{
return(NotFound("Credit Union not found."));
}
else
{
throw;
}
}
return(Ok("Credit Union updated!"));
}
private IMapper ConfigureMapper()
{
var mapperConfiguration = new MapperConfiguration(config => {
ApiMapper.Config(config);
DomainMapper.Config(config);
});
return(mapperConfiguration.CreateMapper());
}
public void ConfigureServices(IServiceCollection services)
{
ApiMapper.Configure();
services.AddControllers();
services.AddDbContext <RepositoryDbContext>(c => c.UseSqlServer(Configuration.GetConnectionString("connectionName")));
services.AddRepository();
services.AddMensageria();
services.AddServices();
services.AddJwtBearer(Configuration);
services.AddCors(options =>
{
options.AddPolicy(corsPolicy,
builder => builder
.AllowAnyOrigin()
.AllowAnyMethod()
.AllowAnyHeader());
});
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1",
new OpenApiInfo
{
Title = "Api Restaurante Favo de Mel",
Version = "v1",
Description = "API REST Restaurante Favo de Mel",
Contact = new OpenApiContact
{
Name = "Jonathan D. C. Santiago",
Url = new Uri("https://github.com/jonathandsantiago/Arquitetura")
}
});
c.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme
{
Description = "JWT Authorization header using the Bearer scheme. Example: \"Authorization: Bearer {token}\"",
Name = "Authorization",
In = ParameterLocation.Header,
Type = SecuritySchemeType.ApiKey,
Scheme = "Bearer"
});
c.AddSecurityRequirement(new OpenApiSecurityRequirement
{
{
new OpenApiSecurityScheme
{
Reference = new OpenApiReference {
Type = ReferenceType.SecurityScheme,
Id = "Bearer"
}
}, new List <string>()
}
});
});
}
public Task<IEnumerable<ApiResource>> FindApiResourcesByScopeAsync(IEnumerable<string> scopeNames)
{
var apis = _repo.FindApiRecourceByScopesAsync(scopeNames).Result; //ApiResourcesConfig.GetApis();
List<ApiResource> result = new List<ApiResource>();
foreach (ApiResourcePoco a in apis)
{
result.Add(ApiMapper.Map(a));
}
return Task.FromResult<IEnumerable<ApiResource>>(result);
}
public async Task <ActionResult> GetBudgets(int id)
{
var budgets = await _repo.GetBudgetByIdAsync(id);
var resource = ApiMapper.MapBudgets(budgets);
if (budgets == null)
{
return(NotFound());
}
return(Ok(resource));
}
public async Task <ActionResult> GetSubscriptions(int id)
{
var Subscriptions = await _repo.GetSubscriptionsByIdAsync(id);
var resource = ApiMapper.MapSub(Subscriptions);
if (Subscriptions == null)
{
return(NotFound());
}
return(Ok(resource));
}
public Startup(IHostingEnvironment env)
{
var builder = new ConfigurationBuilder()
.SetBasePath(env.ContentRootPath)
.AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
.AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true)
.AddEnvironmentVariables();
Configuration = builder.Build();
//初始化映射
ApiMapper.Initialize();
}
public async Task <ActionResult> GetLoanApplication(int id)
{
var loan = await _repo.GetLoanApplicationByIdAsync(id);
var resource = ApiMapper.MapApplication(loan);
if (resource != null)
{
return(Ok(resource));
}
return(NotFound());
}
public async Task <ActionResult> PostCreditUnion(ApiCreditUnion creditUnion)
{
try
{
var resource = ApiMapper.MapUnion(creditUnion);
await _repo.AddCreditUnionAsync(resource);
return(Ok("Credit Union has been added!"));
}
catch (Exception)
{
return(BadRequest("Something went wrong"));
}
}
public async Task <ActionResult> PostUsers(ApiUsers users)
{
try
{
var resource = ApiMapper.MapUsers(users);
await _repo.AddUserAsync(resource);
return(Ok("User added!"));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public ApiResponse <IEnumerable <ApiModels.Audio> > GetAudios(AudioRequest request)
{
//builder user id list
IEnumerable <int> userIds = request.Users.Select(x => x.UserId);
//exclude old audios and get only audios for special users
IQueryable <DataModels.Audio> audioQry = _dbContext
.Audios
.Where(x => !request.ExcludeAudios.Contains(x.Id) &&
userIds.Contains(x.UserId))
.OrderBy(x => Guid.NewGuid());
var audioQryList = new List <IQueryable <DataModels.Audio> >();
//builder queries
foreach (var req in request.Users)
{
IQueryable <DataModels.Audio> userAudioQry = _dbContext
.Audios
.Where(x => x.UserId == req.UserId);
if (!req.IsAudioMixes)
{
userAudioQry = userAudioQry.OrderBy(x => x.Order);
}
userAudioQry = userAudioQry.Take(req.AudioCount);
audioQryList.Add(userAudioQry);
}
IQueryable <DataModels.Audio> totalAudioQry = audioQryList.FirstOrDefault() ??
Enumerable.Empty <DataModels.Audio>().AsQueryable();
for (int i = 1; i < audioQryList.Count; i++)
{
totalAudioQry = totalAudioQry.Concat(audioQryList[i]);
}
//materialize audios
return(new ApiResponse <IEnumerable <ApiModels.Audio> >()
{
Ok = true,
Data = totalAudioQry
.ToList()
.Select(x => ApiMapper.GetAudio(x)),
});
}
public async Task <ActionResult> GetUsers(int id)
{
try
{
if (await _repo.GetUserById(id) is CoreUsers sub)
{
var resource = ApiMapper.MapUsers(sub);
return(Ok(resource));
}
}
catch (NullReferenceException)
{
return(NotFound($"No Users with an id of {id} was found."));
}
return(Ok("There are no Users."));
}
public async Task <ActionResult> GetLoan(int id)
{
try
{
if (await _repo.GetLoanById(id) is CoreLoan loan)
{
var transformed = ApiMapper.MapLoan(loan);
return(Ok(transformed));
}
}
catch (NullReferenceException)
{
return(NotFound($"No loan with the id of {id}."));
}
return(Ok("There is no loan."));
}
public async Task <ActionResult> GetNonBills(int id)
{
try
{
if (await _repo.GetNonBillById(id) is CoreNonBills bill)
{
var resource = ApiMapper.MapNonBills(bill);
return(Ok(resource));
}
}
catch (NullReferenceException)
{
return(NotFound($"No Non-bill with the id of {id}."));
}
return(Ok("There are no Non-bills."));
}
public async Task <ActionResult> GetBills(int id)
{
try
{
if (await _repo.GetBillById(id) is CoreBills bill)
{
var transformed = ApiMapper.MapBills(bill);
return(Ok(transformed));
}
}
catch (NullReferenceException)
{
return(NotFound($"No bill with the id of {id}."));
}
return(Ok("There are no bills."));
}
public async Task <ActionResult> GetCreditUnion(int id)
{
try
{
if (await _repo.GetCreditUnionById(id) is CoreCreditUnion union)
{
var transformed = ApiMapper.MapUnion(union);
return(Ok(transformed));
}
}
catch (NullReferenceException)
{
return(NotFound($"No credit union with the id of {id}."));
}
return(NotFound("There is no Credit Union by that Id."));
}
public void MapLoanApi_StateUnderTest_ExpectedBehavior()
{
var apiMapper = this.CreateApiMapper();
CoreLoan loan = new CoreLoan
{
AccumulatedCost = 1,
Id = 1,
InterestRate = 1,
MonthlyRate = 1,
RetainingCost = 1,
UserId = 1
};
var result = ApiMapper.MapLoanApi(
loan);
Assert.True(true);
this.mockRepository.VerifyAll();
}
public async Task <ActionResult> GetBudget(int id)
{
try
{
if (await _repo.GetBudgetById(id) is CoreBudget budget)
{
var transformed = ApiMapper.MapBudgets(budget);
return(Ok(transformed));
}
}
catch (NullReferenceException)
{
return(NotFound($"No budgets with the Id of {id}."));
}
return(Ok("No budgets found"));
}
public void MapUserApi_StateUnderTest_ExpectedBehavior()
{
var apiMapper = this.CreateApiMapper();
CoreUsers users = new CoreUsers
{
Address = "Address",
Email = "Email",
Id = 1,
Membership = false,
Name = "Danny devito",
Password = "******",
PhoneNumber = "1234",
};
var result = ApiMapper.MapUserApi(
users);
Assert.True(true);
}
public void MapSub_StateUnderTest_ExpectedBehavior()
{
var apiMapper = this.CreateApiMapper();
CoreSubscriptions sub = new CoreSubscriptions
{
Company = "company",
Id = 1,
Notification = true,
SubscriptionDate = new DateTime(),
SubscriptionDueDate = new DateTime(),
SubscriptionMonthCost = 1,
SubscriptionName = "name",
UserId = 1
};
var result = ApiMapper.MapSub(
sub);
Assert.True(true);
}
public void MapBillsApi_StateUnderTest_ExpectedBehavior()
{
var apiMapper = this.CreateApiMapper();
CoreBills bills = new CoreBills
{
BillDate = new DateTime(),
Cost = 1,
Id = 1,
Location = "location",
PurchaseName = "purchase",
Quantity = 1,
UserId = 1,
};
var result = ApiMapper.MapBillsApi(
bills);
Assert.True(true);
this.mockRepository.VerifyAll();
}
public ApiResponse <IEnumerable <ApiModels.User> > GetUsers(string searchString, int skip, int take)
{
if (take <= 0 || string.IsNullOrWhiteSpace(searchString))
{
return new ApiResponse <IEnumerable <ApiModels.User> >()
{
Ok = true,
Data = Enumerable.Empty <ApiModels.User>(),
}
}
;
if (skip < 0)
{
skip = 0;
}
int exludeMarker = int.MaxValue;
IEnumerable <ApiModels.User> apiUserList =
(from u in _dbContext.Users
select new
{
User = u,
Rank = u.LastName.StartsWith(searchString) ? 1 :
(u.FirstName + " " + u.LastName).StartsWith(searchString) ? 2 :
u.FirstName.StartsWith(searchString) ? 3 :
u.Id.ToString() == searchString ? 4 : exludeMarker,
} into _u
where _u.Rank != exludeMarker
orderby _u.Rank, _u.User.FirstName, _u.User.LastName
select _u.User)
.Skip(skip)
.Take(take)
.ToList()
.Select(x => ApiMapper.GetUser(x));
return(new ApiResponse <IEnumerable <ApiModels.User> >()
{
Data = apiUserList,
Ok = true,
});
}
public void MapBudgets_StateUnderTest_ExpectedBehavior()
{
var apiMapper = this.CreateApiMapper();
CoreBudgets budgets = new CoreBudgets
{
ActualCost = 1,
EstimatedCost = 1,
Id = 1,
Loan = null,
Subscription = null,
UserId = 1,
};
var result = ApiMapper.MapBudgets(
budgets);
// Assert
Assert.True(true);
this.mockRepository.VerifyAll();
}
