Ocelot | .NET core API Gateway | Microservice library

openapi-generator-cli generate -g typescript-angular -o ./openapi -i http://localhost:xxxx/swagger/docs/v1/project

dict={

    'Animal':['Cat', 'Dog', 'Ocelot'],
    'Humans':['Jack', 'Jill', 'Frank'], 
    'Fruit':['Apple', 'Orange', 'Banana']
}

const quizButton = document.getElementById("quiz-button");

/*  =========================
    Question and answer pairs
    =========================
*/
let shortQuizPrompts = 
   [{prompt: "10 + 10\n(a) 10\n(b) 15\n(c) 20\n(d) 25", answer: "c"},
    {prompt: "What status did astronomers downgrade Pluto to in 2006?\n(a) Dwarf Planet\n(b) White Dwarf\n(c) Black Dwarf\n(d) Dwarf Star", answer: "a"},
    {prompt: 'What tart fruit has a sweet variety called "Meyer"?\n(a) lime\n(b) lemon\n(c) grapefruit\n(d) dragonfruit', answer: "c"},
    {prompt: `What bird lays its eggs in other birds' nests?\n(a) Blue Jay\n(b) Robin\n(c) Eagle\n (d) Cuckoo`, answer: "d"},
    {prompt: `What is a female goat called?\n(a) a foe\n(b) a larp\n(c) a nanny\n(d) a maur`, answer:"c"},
    {prompt: `What is Eisoptrophobia? \n(a) the fear of mirrors\n(b) the fear of cold temperatures\n(c) the fear of farm animals\n(d) the fear of viruses`, answer: `a`},
    {prompt: `Which element of the periodic table is named after the sun?\n(a) slinerium\n(b) helium\n(c) magnesium\n(d) uranium`, answer: `b`},
    {prompt: `What color is the octopus blood?\n(a) pink\n(b) light green\n(c) violet\n(d) light blue`, answer: `d`},
    {prompt: `What value does the Roman numeral C represent?\n(a) 20\n(b) 50\n(c) 100\n(d) 200`, answer: `c`},
    {prompt: `What is measured in fathoms?\n(a) depth of water \n(b) sound \n(c) pressure \n(d) light`, answer: `a`},
    {prompt: `What is Chiroptophobia?\n(a) fear of plants \n(b) fear of insects\n(c) fear of chirogenics \n(d) fear of bats`, answer: `d`},
    {prompt: `What is the longest and heaviest bone in the human body?\n(a) tibia\n(b) skull\n(c) femur\n(d) humorous`, answer: `c`},
    {prompt: `What are the two major elements making up the sun?\n(a) hydrogen and helium\n(b) nitrogen and hydrogen\n(c) oxygen and nitrogen\n(d) oxygen and hydrogen`, answer: `a`},
    {prompt: `What is poliosis?\n(a) a disease impacting your balance\n(b) graying of hair\n(c) loss of hair\n(d) high potassium pressence in blood`, answer: `b`},
    {prompt: `When held to ultraviolet light, what animal’s urine glows in the dark?\n(a) lemur\n(b) cat\n(c) dog\n(d) lamb`, answer: ``},
    {prompt: `What year did the "ILOVEYOU" virus began infecting computers worldwide?\n(a) 2000\n(b) 2001\n(c) 2002\n(d) 2004`, answer: `a`},
    {prompt: `What planet's four largest moons are collectively known as the Galilean Moons?\n(a) neptune\n(b) jupiter\n(c) saturn\n(d) uranus`, answer: `b`},
    {prompt: `What North American mammal is also known as the prairie wolf or brush wolf?\n(a) brown bears\n(b) ocelots\n(c) coyotes\n(d) hyenas`, answer: `c`},
    {prompt: `How often are brain cells replaced?\n(a) once every few hours\n(b) once every few days\n(c) once every few weeks\n(d) never`, answer: `d`},
    {prompt: `What physical property of a diamond do carats measure?\n(a) mass\n(b) purity \n(c) color quality\n(d) mineral composition`, answer: `a`},
    {prompt: `Nosocomephobia is the fear of what?\n(a) night time\n(b) very large objects\n(c) hospitals\n(d) loud noises`, answer: `c`},
    {prompt: `In what year did the Soviet Union launch its first Sputnik satellite?\n(a) 1049\n(b) 1957\n(c) 1963\n(d)1972`, answer: `b`},
    {prompt: `What is measured in Ergs?\n(a) Work\n(b) mass\n(c) depth\n(d) emotion`, answer: `a`},
    {prompt: `What does a Scoville unit measure?\n(a) sourness\n(b) pain\n(c) spiciness\n(d) taste`, answer: `c`},];
    
    
    
    
    /*  ======================
        initiation of the quiz
        ======================
    */
   
        quizButton.onclick = () => {
        let correct = 0;
        const amountOfQuestions = prompt(`How many questions do you want? There are ${shortQuizPrompts.length} maximum`);
        alert('You are about to start the quiz. \nFor each question, enter either "a", "b", "c", or "d". \nPress enter to continue');
        for(i = 0; i< amountOfQuestions; i++) {
           const answer = prompt(shortQuizPrompts[i].prompt);
            if(answer === shortQuizPrompts[i].answer && answer !== null && answer !== undefined) {
                alert("Correct");
                correct++;
            } else if (answer !== shortQuizPrompts[i].answer && answer !==null && answer !== undefined && answer.length >= 1 && (answer === "a" || answer === "b" || answer === "c" || answer === "d")) {
                alert("Incorrect");
            } else if (answer === null) {
                alert(`Bruh, why'd you start the quiz if you didnt want to answer the questions lol`);
            } else if (answer.length == 0) {
                setInterval(alert("Trying to skip questions, I see?? Yeah, you thought you weren't gonna get caught, huh? Well think again")), 100;
            }
            console.log(answer)
            if(i === amountOfQuestions - 1 && (Math.floor(correct / amountOfQuestions * 100)) <= 33) {
                alert(`Wow, you're bad! You made a ${Math.floor((correct / amountOfQuestions) * 100).toFixed(2)}% getting ${correct} out of ${amountOfQuestions} questions correct!`);
        
            }
    
            if(i === amountOfQuestions - 1 && (Math.floor(correct / amountOfQuestions * 100)) > 33 && (Math.floor(correct / amountOfQuestions * 100)) <= 66) {
                alert(`You did ok. You made a ${Math.floor((correct / amountOfQuestions) * 100).toFixed(2)}% getting ${correct} out of ${amountOfQuestions} questions right!`);
        
            }
    
            if(i === amountOfQuestions - 1 && (Math.floor(correct / amountOfQuestions * 100)) > 66 ) {
                alert(`Congratulations! 🎉 You made a ${Math.floor((correct / amountOfQuestions) * 100).toFixed(2)}% getting ${correct} out of ${amountOfQuestions} questions right!`);
            }
            if(answer !== "a" && answer !== "b" && answer!== "c" && answer !== "d" && answer.length > 0 && answer !== null && answer !== undefined) {
                alert(`What are you doing? I told you to only enter "a", "b", "c", or "d" as answers`);
            }
        }
    
    }

* {
    box-sizing: border-box;
}

button {
    cursor: pointer;
}

#quiz-text {
    position: relative;
    left: 42vw;
    top: 25vh;
    transform: translateX(-2%) translateY(5%);
    font-size: 1.5rem;

}

#quiz-button {
    position: relative;
    left: 45vw;
    top: 25vh;
    transform: translateX(-2%) translateY(5%);
    font-size: 20px;
}

    
    
    
    
    
     Random Stuff 


    
Want to take a short quiz?
     START
    

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }

        if (_ocelotSwaggerConfiguration.IsSwaggerEnabled)
        {
            app.UseSwaggerForOcelotUI(Configuration);
        }

        // Enable ReDoc Documentation
        app.UseReDoc(c =>
        {
            c.DocumentTitle = "AI API";
            c.SpecUrl = "/swagger/docs/v1/pitch-ai";
            c.RoutePrefix = string.Empty;
            c.IndexStream = () => Assembly.GetExecutingAssembly()
                .GetManifestResourceStream("AI.Api.Gateway.api_docs.ui.index.html");
            c.HeadContent = GetRedocHeaderContent();
        });

        app.UseAuthentication();
        app.UseStaticFiles();

        app.UseMetricServer();
        app.UseMiddleware();
        app.UseHttpMetrics();
        app.UseWebSockets();
        app.UseHealthChecks("/ready", new HealthCheckOptions
        {
            Predicate = r => r.Tags.Contains("services")
        });

        app.Map("/switch", appBuilder =>
        {
            appBuilder.Run(async context =>
            {
                running = !running;
                await context.Response.WriteAsync($"{Environment.MachineName} running {running}");
            });
        });

        app.UseHealthChecks("/health", new HealthCheckOptions
        {
            Predicate = r => r.Name.Contains("health")
        });

        app.UseMetricsAllEndpoints();
        
        app.UseOcelot().ContinueWith(t => Log.Error(t.Exception.Message, t.Exception), System.Threading.Tasks.TaskContinuationOptions.OnlyOnFaulted);
    }

{
  "Routes": [
    {
      "DownstreamPathTemplate": "/api/post",
      "DownstreamScheme": "https",
      "DownstreamHostAndPorts": [
        {
          "Host": "localhost",
          "Port": 44309
        }
      ],
      "UpstreamPathTemplate": "/gateway/post",
      "UpstreamHttpMethod": [
        "POST",
        "PUT",
        "GET"
      ]
    }
  ]
}

using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using PostService.Repository;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

        namespace PostService.Controllers
        {
            [Route("api/[controller]")]
            [ApiController]
            public class PostController : ControllerBase
            {
                private readonly IPostRepository _postRepository;

                public PostController(IPostRepository postRepository)
                {
                    _postRepository = postRepository;
                }

                [HttpGet]
                public IActionResult Get()
                {
                    var posts = _postRepository.GetPosts();
                    return new OkObjectResult(posts);
                }

            }
        }

https://localhost:44342/gateway/post

    "DownstreamHostAndPorts": [
        {
          "Host": "localhost",
          "Port": 44309
        }
      ],

public void ConfigureServices(IServiceCollection services)
{
    services.AddCors(options =>
    {
        options.AddPolicy("All allowed",
            builder =>
            {
                builder
                    .AllowAnyOrigin()
                    .AllowAnyMethod()
                    .AllowAnyHeader();
            });
    });

    services.AddAuthentication(NegotiateDefaults.AuthenticationScheme)
        .AddNegotiate();
    services.AddAuthorization();

    services.AddControllers();
    services.AddHttpForwarder();
    services.AddOcelot();
    services.AddSwaggerForOcelot(_configuration);
}

public void Configure(IApplicationBuilder app)
{
    app.UseCors("All allowed");

    app.UseRouting();

    app.UseAuthentication();
    app.UseAuthorization();

    app.UseEndpoints(endpoints =>
    {
        endpoints.MapControllers();
    });

    app.UseSwaggerForOcelotUI(options =>
    {
        options.PathToSwaggerGenerator = "/swagger/docs";
    });

    app.UseOcelot();
}

public class Program
{
    public static void Main(string[] args)
    {
        CreateHostBuilder(args).Build().Run();
    }
    public static IHostBuilder CreateHostBuilder(string[] args) =>
         Host.CreateDefaultBuilder(args)
        .ConfigureAppConfiguration((hostingContext, config) =>
                    {
                        config
                            .SetBasePath(hostingContext.HostingEnvironment.ContentRootPath)
                            .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
                            .AddJsonFile($"appsettings.{hostingContext.HostingEnvironment.EnvironmentName}.json", optional: true, reloadOnChange: true)
                            .AddJsonFile($"ocelot.json", optional: false, reloadOnChange: true)
                            .AddEnvironmentVariables();
                    })
                    .ConfigureServices(s =>
                    {
                        s.AddOcelot();
                    })
                    .ConfigureWebHostDefaults(webBuilder =>
                    {
                        webBuilder.UseStartup()
                                  .UseSerilog((_, config) =>
                                  {
                                      config
                                          .MinimumLevel.Information()
                                          .MinimumLevel.Override("Microsoft", LogEventLevel.Warning)
                                          .Enrich.FromLogContext()
                                          .WriteTo.File(@"Logs\AllHttpRequestsLog.txt", rollingInterval: RollingInterval.Day);
                                  })
                                  .Configure(app =>
                                  {
                                      app.UseMiddleware();
                                      app.UseOcelot().Wait();
                                  });
                    });
}

public void ConfigureServices(IServiceCollection services)
{
    // Adding Authentication
    var baseAuthenticationProviderKey = "BaseAuthenticationSchema";

    services.AddAuthentication(options =>
    {
        options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
        options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
        options.DefaultScheme = JwtBearerDefaults.AuthenticationScheme;
    })

    // Adding Jwt Bearer  
    .AddJwtBearer(baseAuthenticationProviderKey, options =>
    {
        options.SaveToken = true;
        options.RequireHttpsMetadata = false;
        options.TokenValidationParameters = new TokenValidationParameters()
        {
            ValidateIssuer = true,
            ValidateAudience = true,
            ValidateIssuerSigningKey = true,
            ValidateLifetime = true,
            ValidAudience = "ValidAudience",
            ValidIssuer = "ValidIssuer ",
            IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("IssuerSigningKey"))
        };
    });

    services.AddControllers();

    services.AddOcelot(_configuration);
}

{
  "DownstreamPathTemplate": "/api/v1/banks",
  "DownstreamScheme": "https",
  "DownstreamHostAndPorts": [
    {
      "Host": "localhost",
      "Port": 44371
    }
  ],
  "UpstreamPathTemplate": "/api/market/banks",
  "UpstreamHttpMethod": [ "Get" ],
  "AuthenticationOptions": {
    "AuthenticationProviderKey": "BaseAuthenticationSchema",
    "AllowedScopes": []
  }
}

    [HttpGet]
    public ActionResult User_Read([DataSourceRequest] DataSourceRequest request)
    {
        var data = _unitOfWork.Repository().GetAll();
        return Ok(data.ToList().ToDataSourceResult(request, ModelState));
    }

{
  "DownstreamPathTemplate": "/api/auth/User_Read/{everything}",
  "DownstreamScheme": "http",
  "DownstreamHostAndPorts": [
    {
      "Host": "localhost",
      "Port": 9001
    }
  ],
  "UpstreamPathTemplate": "/User_Read/{everything}",
  "UpstreamHttpMethod": [ "get" ]
}

          read: function (e) {
        if (thisObject.defaultFilter) {
          if (e.data.filter) {
            var filters = e.data.filter.filters;
            var existFilter = filters.filter(function (obj) {
              if (obj.field == thisObject.defaultFilter.field) return true;
            }).lenght > 0;
            if (!existFilter) e.data.filter.filters.push(thisObject.defaultFilter);
          }
          else {
            e.data.filter = { logic: "and", filters: [thisObject.defaultFilter] }
          }
        }

        const params = `${toDataSourceRequestString(e.data)}`;
        // datasource read request
        thisObject.http.get(thisObject.readUrl + "?" + params).subscribe((res) => {
          e.success(res);
        });
      }

        public void Configure(IApplicationBuilder app, IWebHostEnvironment env, IAuthorizationService authorizationService)
        {
            if (env.EnvironmentName == Environments.Development)
            {
                app.UseDeveloperExceptionPage();
            }

            app.UseAuthentication();

            var configuration = new OcelotPipelineConfiguration
            {
                AuthorizationMiddleware = async (ctx, next) =>
                {

                    if (! await authorizationService.IsValid(ctx))
                    {
                        ctx.Response.StatusCode = (int)HttpStatusCode.Unauthorized;
                        await ctx.Response.WriteAsync("Some Error !");
                    }
                    else
                    {
                        await next.Invoke();
                    }
                },
            };
            app.UseOcelot(configuration).Wait();
        }

        public void ConfigureServices(IServiceCollection services)
        {
            string AuthenticationKey = "AuthenticationKey";
            services.AddLogging();
            services.AddAuthentication(option =>
            {
                option.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
                option.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
            }).AddJwtBearer(AuthenticationKey, option =>
             {
                 option.RequireHttpsMetadata = true;
                 option.SaveToken = true;
                 option.TokenValidationParameters = new TokenValidationParameters
                 {
                     IssuerSigningKey =
                         new SymmetricSecurityKey(
                             Encoding.ASCII.GetBytes(Configuration.GetSection("SecretKey").Value)),
                     ValidateIssuerSigningKey = true,
                     ValidateIssuer = false,
                     ValidateAudience = false
                 };

                 //option.ForwardSignIn

             });

            services.AddHttpClient();

            services.AddScoped();

            services
                .AddOcelot()
                .AddDelegatingHandler();

            services.AddMvc();
        }