public async Task <ActionResult <ApiResponse> > AddRemark([FromBody] AddRemarkRequest remark, [FromServices] IRemarksService remarksService, [FromServices] IUserDetailsProvider userDetailsProvider)
{
var userDetails = userDetailsProvider.GetUserDetails();
var response = await remarksService.AddRemark(userDetails.Email, remark);
return(ApiResponseHelper.Created("Remark created.", response));
}
public async Task OnAuthorizationAsync(AuthorizationFilterContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
// Allow Anonymous skips all authorization
var hasAnonymousFilter = context.Filters.OfType <IAllowAnonymousFilter>().Any();
var hasAnonymouseAttribute = context.ActionDescriptor.EndpointMetadata.OfType <AllowAnonymousAttribute>().Any();
if (hasAnonymousFilter || hasAnonymouseAttribute)
{
return;
}
var policyEvaluator = context.HttpContext.RequestServices.GetRequiredService <IPolicyEvaluator>();
var authenticateResult = await policyEvaluator.AuthenticateAsync(Policy, context.HttpContext);
var authorizeResult = await policyEvaluator.AuthorizeAsync(Policy, authenticateResult, context.HttpContext, context);
if (authorizeResult.Challenged)
{
context.Result = ApiResponseHelper.Unauthorised("Unauthorised.").Result;
}
else if (authorizeResult.Forbidden)
{
context.Result = ApiResponseHelper.Forbidden("Forbidden.", Policy.AuthenticationSchemes.ToArray()).Result;
}
}
public async void HandleException_Should_Set_Response_Body_With_DetailedResponse()
{
var exception = new Exception("ExceptionMessage");
var context = new DefaultHttpContext();
context.Response.Body = new MemoryStream();
await _middleware.HandleException(exception, context);
JToken body;
context.Response.Body.Seek(0, SeekOrigin.Begin);
using (var reader = new StreamReader(context.Response.Body))
{
var content = await reader.ReadToEndAsync();
body = JToken.Parse(content);
}
var expected = ApiResponseHelper.Error("An unhandled exception has occurred.", exception.Message);
var result = (ObjectResult)expected.Result;
var expectedBody = JToken.FromObject(result.Value, new JsonSerializer {
ContractResolver = new CamelCasePropertyNamesContractResolver()
});
body.Should().BeEquivalentTo(expectedBody);
}
private static async Task <TResult?> GetAsync <TResult>(ApiClientService apiClient, string uri)
{
var response = await apiClient.GetAsync <TResult>(uri);
if (!response.IsSuccess)
{
ApiResponseHelper.HandleNotSuccessApiResponse(response);
return(default);
public void OnActionExecuting(ActionExecutingContext context)
{
if (!context.ModelState.IsValid)
{
var errors = context.ModelState
.Where(m => m.Value.Errors.Any())
.Select(m => new { m.Key, m.Value.Errors });
context.Result = ApiResponseHelper.BadRequest("Invalid request format.", errors).Result;
}
}
public async Task <ActionResult <ApiResponse> > GetConditions([FromQuery] string name, [FromQuery] int page, [FromServices] IBittnService bittnService)
{
var response = await bittnService.GetConditions(new GetConditionsRequest
{
Name = name,
PageIndex = page
});
return(ApiResponseHelper.Ok <IllnessDetails>($"{response?.Data?.Count() ?? 0} condition(s) found.", response));
}
public async Task <ActionResult <ApiResponse> > CancelBooking(int bookingId, [FromServices] IBittnService bittnService)
{
var response = await bittnService.CancelBooking(new CancelBookingRequest
{
BookingId = bookingId
});
return(response.Deleted
? ApiResponseHelper.Ok("Booking deleted.", response)
: ApiResponseHelper.Fail("No booking deleted.", response));
}
public async Task <ActionResult <ApiResponse> > GetBookings([FromQuery] int page, [FromQuery] string sortField, [FromQuery] bool?sortDescending, [FromServices] IBittnService bittnService)
{
var response = await bittnService.GetBookings(new GetBookingsRequest
{
PageIndex = page,
SortField = sortField,
SortDescending = sortDescending
});
return(ApiResponseHelper.Ok <BookingDetails>($"{response?.Data?.Count() ?? 0} booking(s) found.", response));
}
public async Task <ActionResult <ApiResponse> > FindHelp([FromBody] FindHelpApiRequest request, [FromServices] IBittnService bittnService)
{
var response = await bittnService.FindHelp(new FindHelpRequest
{
ConditionId = request.ConditionId,
SeverityLevel = request.Severity,
PageIndex = request.Page,
SortField = request.SortField,
SortDescending = request.SortDescending
});
return(ApiResponseHelper.Ok <HelpDetails>($"{response?.Data?.Count() ?? 0} help found.", response));
}
public virtual async Task HandleException(Exception ex, HttpContext context)
{
var message = "An unhandled exception has occurred.";
var response = ApiResponseHelper.Error(message, ex.Message);
var result = (ObjectResult)response.Result;
context.Response.StatusCode = result.StatusCode ?? StatusCodes.Status500InternalServerError;
context.Response.ContentType = "application/json";
await context.Response.WriteAsync(JsonConvert.SerializeObject(result.Value, new JsonSerializerSettings {
ContractResolver = new CamelCasePropertyNamesContractResolver()
}));
}
public void ObjectResponse_Should_Return_Correctly()
{
var actual = ApiResponseHelper.ObjectResponse(StatusCodes.Status100Continue, true, message: "message", "content");
actual.Should().BeOfType <ActionResult <ApiResponse> >();
actual.Result.Should().BeOfType <ObjectResult>();
actual.Result.As <ObjectResult>().StatusCode.Should().Be(StatusCodes.Status100Continue);
actual.Result.As <ObjectResult>().Value.Should().BeOfType <ApiResponse>();
actual.Result.As <ObjectResult>().Value.As <ApiResponse>().Success.Should().Be(true);
actual.Result.As <ObjectResult>().Value.As <ApiResponse>().Message.Should().Be("message");
actual.Result.As <ObjectResult>().Value.As <ApiResponse>().Data.Should().Be("content");
}
public async Task <ActionResult <ApiResponse> > BookPatient([FromBody] BookPatientApiRequest request, [FromServices] IBittnService bittnService)
{
var response = await bittnService.BookPatient(new BookPatientRequest
{
ConditionId = request.ConditionId,
ConditionName = request.ConditionName,
HelpId = request.HelpId,
HelpName = request.HelpName,
PatientName = request.PatientName,
SeverityLevel = request.Severity
});
return(ApiResponseHelper.Ok($"Booking created.", response));
}
public void Created_Should_Return_Correctly()
{
var message = "message";
var actual = ApiResponseHelper.Created(message);
actual.Should().BeOfType <ActionResult <ApiResponse> >();
actual.Result.Should().BeOfType <ObjectResult>();
actual.Result.As <ObjectResult>().StatusCode.Should().Be(StatusCodes.Status201Created);
actual.Result.As <ObjectResult>().Value.Should().BeOfType <ApiResponse>();
actual.Result.As <ObjectResult>().Value.As <ApiResponse>().Success.Should().Be(true);
actual.Result.As <ObjectResult>().Value.As <ApiResponse>().Message.Should().Be(message);
actual.Result.As <ObjectResult>().Value.As <ApiResponse>().Data.Should().BeNull();
}
public void Error_Should_Return_Correctly()
{
var message = "message";
var actual = ApiResponseHelper.Error(message);
actual.Should().BeOfType <ActionResult <ApiResponse> >();
actual.Result.Should().BeOfType <ObjectResult>();
actual.Result.As <ObjectResult>().StatusCode.Should().Be(StatusCodes.Status500InternalServerError);
actual.Result.As <ObjectResult>().Value.Should().BeOfType <ApiResponse>();
actual.Result.As <ObjectResult>().Value.As <ApiResponse>().Success.Should().Be(false);
actual.Result.As <ObjectResult>().Value.As <ApiResponse>().Message.Should().Be(message);
actual.Result.As <ObjectResult>().Value.As <ApiResponse>().Data.Should().BeNull();
}
public void Forbidden_Should_Return_Correctly()
{
var message = "message";
var actual = ApiResponseHelper.Forbidden(message);
actual.Should().BeOfType <ActionResult <ApiResponse> >();
actual.Result.Should().BeOfType <ObjectResult>();
actual.Result.As <ObjectResult>().StatusCode.Should().Be(StatusCodes.Status403Forbidden);
actual.Result.As <ObjectResult>().Value.Should().BeOfType <ApiResponse>();
actual.Result.As <ObjectResult>().Value.As <ApiResponse>().Success.Should().Be(false);
actual.Result.As <ObjectResult>().Value.As <ApiResponse>().Message.Should().Be(message);
actual.Result.As <ObjectResult>().Value.As <ApiResponse>().Data.Should().BeNull();
}
public void Fail_Should_Return_Correctly_With_Data()
{
var content = "content";
var message = "message";
var actual = ApiResponseHelper.Fail(message, content);
actual.Should().BeOfType <ActionResult <ApiResponse> >();
actual.Result.Should().BeOfType <ObjectResult>();
actual.Result.As <ObjectResult>().StatusCode.Should().Be(StatusCodes.Status200OK);
actual.Result.As <ObjectResult>().Value.Should().BeOfType <ApiResponse>();
actual.Result.As <ObjectResult>().Value.As <ApiResponse>().Success.Should().Be(false);
actual.Result.As <ObjectResult>().Value.As <ApiResponse>().Message.Should().Be(message);
actual.Result.As <ObjectResult>().Value.As <ApiResponse>().Data.Should().Be(content);
}
public void BadRequest_Should_Return_Correctly()
{
var message = "message";
var actual = ApiResponseHelper.BadRequest(message);
actual.Should().BeOfType <ActionResult <ApiResponse> >();
actual.Result.Should().BeOfType <ObjectResult>();
actual.Result.As <ObjectResult>().StatusCode.Should().Be(StatusCodes.Status400BadRequest);
actual.Result.As <ObjectResult>().Value.Should().BeOfType <ApiResponse>();
actual.Result.As <ObjectResult>().Value.As <ApiResponse>().Success.Should().Be(false);
actual.Result.As <ObjectResult>().Value.As <ApiResponse>().Message.Should().Be(message);
actual.Result.As <ObjectResult>().Value.As <ApiResponse>().Data.Should().BeNull();
actual.Result.As <ObjectResult>().Value.As <ApiResponse>().Navigation.Should().BeNull();
}
public IActionResult SignOut()
{
// Initiate the SignOut flow if the user is authenticated
if (User.Identity.IsAuthenticated)
{
var redirectUrl = Request.GetDisplayUrl();
return(SignOut(new Microsoft.AspNetCore.Authentication.AuthenticationProperties {
RedirectUri = redirectUrl
},
CookieAuthenticationDefaults.AuthenticationScheme, OpenIdConnectDefaults.AuthenticationScheme));
}
else
{
// If the user is signed out already, reply with the relevant success message
return(ApiResponseHelper.GetApiResponse(DataConstant.Authentication202));
}
}
public IActionResult AcquireToken()
{
// Return the authentication token if the user is authenticated.
if (HttpContext.User.Identity.IsAuthenticated && !string.IsNullOrWhiteSpace(HttpContext.Session.GetString(DataConstant.IdToken)))
{
return(ApiResponseHelper.GetApiResponse(DataConstant.Authentication201, HttpContext.Session.GetString(DataConstant.IdToken)));
}
else
{
// Redirect to authentication flow if the user is not signed-in
var redirectUrl = Request.GetDisplayUrl();
return(Challenge(
new Microsoft.AspNetCore.Authentication.AuthenticationProperties {
RedirectUri = redirectUrl
},
OpenIdConnectDefaults.AuthenticationScheme));
}
}
static void Main(string[] args)
{
ApiHelper.InitializeClient();
while (true)
{
Console.Clear();
Console.Write("Enter username: "******"Enter password: "******"\n\n\n");
string token = ApiResponseHelper.GetToken(loginResult);
JObject tokenResult = ApiRequestHelper.GetResultWithToken(token);
if (!ApiResponseHelper.IsRequestSucceeded(tokenResult))
{
Console.WriteLine("Token not valid.");
}
else
{
Console.WriteLine($"\n\n======================LOGIN SUCCEEDED======================\n\n");
Console.WriteLine($"Username : {username}");
Console.WriteLine($"\nMESSAGE : {ApiResponseHelper.GetMessage(tokenResult)}");
Console.WriteLine("\n\nPress ENTER to continue...");
}
}
else
{
Console.WriteLine("\n\nWrong username or password.");
Console.WriteLine("\nPress ENTER to try again...");
}
Console.ReadLine();
}
}
public void ObjectResponse_Should_Return_PagedResponse_Correctly()
{
var content = new PagedResponse <string>
{
Data = new [] { "data" },
PrevPageIndex = 111,
NextPageIndex = 222
};
var actual = ApiResponseHelper.ObjectResponse(StatusCodes.Status100Continue, true, message: "message", content: content);
actual.Should().BeOfType <ActionResult <ApiResponse> >();
actual.Result.Should().BeOfType <ObjectResult>();
actual.Result.As <ObjectResult>().StatusCode.Should().Be(StatusCodes.Status100Continue);
actual.Result.As <ObjectResult>().Value.Should().BeOfType <ApiResponse>();
actual.Result.As <ObjectResult>().Value.As <ApiResponse>().Success.Should().Be(true);
actual.Result.As <ObjectResult>().Value.As <ApiResponse>().Message.Should().Be("message");
actual.Result.As <ObjectResult>().Value.As <ApiResponse>().Data.Should().Be(content.Data);
actual.Result.As <ObjectResult>().Value.As <ApiResponse>().Navigation.PrevPageIndex.Should().Be(content.PrevPageIndex);
actual.Result.As <ObjectResult>().Value.As <ApiResponse>().Navigation.NextPageIndex.Should().Be(content.NextPageIndex);
}
public void Ok_Should_Return_Correctly_With_PagedResponse_Data()
{
var content = new PagedResponse <string>
{
Data = new [] { "data" },
PrevPageIndex = 111,
NextPageIndex = 222
};
var message = "message";
var actual = ApiResponseHelper.Ok(message, content);
actual.Should().BeOfType <ActionResult <ApiResponse> >();
actual.Result.Should().BeOfType <ObjectResult>();
actual.Result.As <ObjectResult>().StatusCode.Should().Be(StatusCodes.Status200OK);
actual.Result.As <ObjectResult>().Value.Should().BeOfType <ApiResponse>();
actual.Result.As <ObjectResult>().Value.As <ApiResponse>().Success.Should().Be(true);
actual.Result.As <ObjectResult>().Value.As <ApiResponse>().Message.Should().Be(message);
actual.Result.As <ObjectResult>().Value.As <ApiResponse>().Data.Should().Be(content.Data);
actual.Result.As <ObjectResult>().Value.As <ApiResponse>().Navigation.PrevPageIndex.Should().Be(content.PrevPageIndex);
actual.Result.As <ObjectResult>().Value.As <ApiResponse>().Navigation.NextPageIndex.Should().Be(content.NextPageIndex);
}
public async Task <ActionResult <ApiResponse> > Register([FromBody] SecurityRequest request, [FromServices] ISecurityService securityService)
{
var response = await securityService.Register(request);
return(ApiResponseHelper.Created("User created.", response));
}
public async Task <JsonResult <DtoChargeResponseMessage> > ExecuteAsync(DtoChargeRequestMessage dtoChargeRequestMessage)
{
try
{
DtoCustomerModel dtoCustomerModel;
if (string.IsNullOrEmpty(dtoChargeRequestMessage.customer_id))
{
//var customVariables = new List<CustomVariables>
//{
// new CustomVariables {name = "Tipo", value = "Pizzaria"},
// new CustomVariables {name = "Gerente", value = "Fernando Chilvarguer"}
//};
var customer = new DtoCustomerRequestMessage
{
email = dtoChargeRequestMessage.payer.email,
name = dtoChargeRequestMessage.payer.name,
cpf_cnpj = dtoChargeRequestMessage.payer.cpf_cnpj,
//notes = dtoChargeRequestMessage.notes,
//custom_variables = customVariables,
};
using (var apiCustomer = new Customer())
{
/*"ccf9fdba30425bd85516114e976b53b0"*/
dtoCustomerModel = await apiCustomer.CreateAsync(customer, dtoChargeRequestMessage.token).ConfigureAwait(false);
};
dtoChargeRequestMessage.customer_id = dtoCustomerModel.id;
}
//else
//{
// using (var apiClient = new Customer())
// {
// dtoCustomerModel = await apiClient.GetAsync(Guid.NewGuid().ToString()).ConfigureAwait(false);
// };
//}
dtoChargeRequestMessage = NovoRequestCriarBoletos(dtoChargeRequestMessage);
DtoChargeResponseMessage chargeTokenResponse;
using (var apiCharge = new Charge())
{
chargeTokenResponse = await apiCharge.CreateAsync(dtoChargeRequestMessage).ConfigureAwait(false);
}
return(Json(chargeTokenResponse));
}
catch (GnException e)
{
SaeIuguApiStatus.SetNovoException(e);
var dtoResponseBoletos = new DtoChargeResponseMessage()
{
success = false,
message = ApiResponseHelper.GetApiResponseMessage(e.Code, e.Message, false),
errors = new Dictionary <string, object>()
{
{ "exception", new DtoExceptionMessage()
{
property = e.Code.ToString(),
message = e.ErrorType
} }
}
};
return(Json(dtoResponseBoletos));
}
catch (Exception e)
{
SaeIuguApiStatus.SetNovoException(e);
var dtoChargeResponseMessage = new DtoChargeResponseMessage()
{
success = false,
message = e.Message,
errors = new Dictionary <string, object>()
{
{ "exception", new DtoExceptionMessage()
{
property = "exception",
message = e.Message
} }
}
};
return(Json(dtoChargeResponseMessage));
}
}
/// <summary>
/// This method gets called by the runtime. Use this method to add services to the container.
/// </summary>
/// <param name="services"> The Service collection</param>
public void ConfigureServices(IServiceCollection services)
{
// Enable logging from authentication flow
IdentityModelEventSource.ShowPII = true;
// Any exception occurred in Startup constructor then return to Configure method
// there application will return with custom exception response.
if (StartupException != null)
{
return;
}
try
{
services.AddMvcCore(filter =>
{
filter.Filters.Add(typeof(ExceptionAttribute));
});
services.AddSingleton <IHttpContextAccessor, HttpContextAccessor>();
// To configure application settings to service
services.Configure <AppSettings>(configuration.GetSection(DataConstant.Appsettings));
configuration.Bind(DataConstant.Appsettings, appSettings);
configuration.Bind(DataConstant.ApplicationInsights, appSettings.ApplicationInsights);
services.AddAuthentication(sharedOptions =>
{
sharedOptions.DefaultScheme = CookieAuthenticationDefaults.AuthenticationScheme;
sharedOptions.DefaultChallengeScheme = OpenIdConnectDefaults.AuthenticationScheme;
})
.AddAzureAdB2C(options => configuration.Bind(DataConstant.AppSettingsAzureAdB2C, options))
.AddCookie();
services.AddSingleton(appSettings);
services.AddSingleton(configuration);
services.AddSingleton(appSettings.AzureAdB2C);
services.AddSingleton(appSettings.ApplicationInsights);
// Add framework services
// Contract resolver is initialized since default resolver is set as CamelCasePropertyNamesContractResolver by .Net core if not initialized
services.AddControllers().AddNewtonsoftJson(options =>
{
// Use the default property (Pascal) casing
options.SerializerSettings.ContractResolver = new DefaultContractResolver();
});
// Adds a default in-memory implementation of IDistributedCache.
services.AddDistributedMemoryCache();
services.AddSession();
// Add application settings helper to service in order to access values.
ConfigHelper configHelper = new ConfigHelper(appSettings);
services.AddSingleton(typeof(ConfigHelper));
// Add Api Response Helper to service to use configuration.
ApiResponseHelper Helper = new ApiResponseHelper(configuration);
services.AddSingleton(typeof(ApiResponseHelper));
services.AddHttpContextAccessor();
}
catch (Exception exception)
{
StartupException = exception;
}
}
public async Task <ActionResult <ApiResponse> > GetRemarks([FromQuery] string filter, [FromServices] IRemarksService remarksService)
{
var response = await remarksService.GetRemarks(filter);
return(ApiResponseHelper.Ok($"{response.Count()} remark(s) found.", response));
}
public async Task <ActionResult <ApiResponse> > UpdateRemark(string remarkId, [FromBody] UpdateRemarkRequest updates, [FromServices] IRemarksService remarksService)
{
await remarksService.UpdateRemark(remarkId, updates);
return(ApiResponseHelper.Ok("Remark updated.", remarkId));
}
public async Task <ActionResult <ApiResponse> > DeleteRemark(string remarkId, [FromServices] IRemarksService remarksService)
{
await remarksService.DeleteRemark(remarkId);
return(ApiResponseHelper.Ok("Remark deleted.", remarkId));
}
public async Task <ActionResult <ApiResponse> > LogIn([FromBody] SecurityRequest request, [FromServices] ISecurityService securityService)
{
var response = await securityService.LogIn(request);
return(ApiResponseHelper.Ok("User logged in.", response));
}
