FizzBuzzEnterpriseEdition | FizzBuzz Enterprise Edition is a nononsense implementation | Runtime Evironment library

auth: {
    user: 'myusername',
    pass: 'mypassword'
},

require ('dotenv').config();

auth: {
  user: process.env.USERNAME,
  pass: process.env.PASSWORD
},

public function compute($oleId)
    {
        try {
            ini_set('memory_limit', '-1');
            set_time_limit(0);

            DB::beginTransaction();

            /* Get the Exam */
            $exam = OlympiadExam::query()->where('ole_id', $oleId)->first();

            /* Calculate the score of Exam */
            if ($exam->ole_is_main == '0') {
                foreach ($exam->olympiadExamExecution as $execution) {
                    $questions = $execution->load('olympiadExamExecutionQuestion.olympiadExamQuestion');
                    $all = $exam->ole_question_count;
                    $notAnswered = $questions->olympiadExamExecutionQuestionNotAnswered->where('oee_oex_id', $execution->oex_id)->count();
                    $answered = $all - $notAnswered;
                    $truthy = $questions->olympiadExamExecutionQuestionTruthy->where('oee_oex_id', $execution->oex_id)->count();
                    $falsy = $all - ($truthy + $notAnswered);

                    $score = (float)($truthy - ($falsy / 3));
                    $percentage = (float)((($truthy * 3) - $falsy) / ($all * 3)) * 100;

                    $prePositive = (float)$percentage * ($exam->ole_percent_effect / 100);
                    $percentPositive = ($prePositive > 0) ? $prePositive : 0;
                    $percentFinal = (($percentage + $percentPositive) > 100) ? 100 : ($percentage + $percentPositive);
                    $scoreFinal = ((($percentFinal * $all) / 100) > $all) ? $all : ($percentFinal * ($all / 100));

                    $examResult = [
                        'oex_correct_answer_count' => $truthy,
                        'oex_wrong_answer_count' => $falsy,
                        'oex_no_answer_count' => $notAnswered,
                        'oex_score' => $score,
                        'oex_percent' => $percentage,
                        'oex_percent_positive' => $percentPositive,
                        'oex_percent_final' => $percentFinal,
                        'oex_score_final' => $scoreFinal,
                    ];

                    OlympiadExamExecution::query()->where('oex_id', $execution->oex_id)->update($examResult);
                }
            }

            $candidates = OlympiadExamExecution::query()->where('oex_ole_id', $oleId)->pluck('oex_percent_final')->toArray();
            if (!empty($candidates)) {
                $this->computeRank($candidates);
            }
            DB::commit();
            session()->flash('computeStatus', 'Process for calculating score completed');
            return redirect()->back();
        } catch (\Exception $exception) {
            DB::rollBack();
            session()->flash('computeStatus', 'Process for calculating score is going wrong');
            return redirect()->back();
        }

    }

    let http = require('http')
    
    let server = http.createServer(function (req, res) {
        if (req.method === 'POST') {
            console.log('sleeping..💤💤')
            var ffi = require('ffi-napi')
            var powrprof = ffi.Library('powrprof.dll', {
                SetSuspendState: ['int', ['int', 'int', 'int']],
            })
    
            function invokeStandby() {
                powrprof.SetSuspendState(0, 0, 0)
            }
            // invokeStandby()
        } else {
            res.writeHead(405, { 'Content-Type': 'text/plain' })
            res.end('Method Not Allowed\n')
        }
    })
    
    server.listen(8443)

    console.log('Server running on port 8443')

    server{
    listen 80;
    server_name xx.xx.xxx.xxx;

    location / {
        root /var/www/kioskJPE/html;
        index index.html;
    }
    location /upload {
        root /var/www/fileUpload/html;
        index index.html;
    }
    location /uploadFiles {
        proxy_pass http://localhost:8080;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
    }
}

func routes(_ app: Application throws {
    app.on(.POST, "website_form") { req -> EventLoopFuture<View> in
        var form: FromRequest = /*initial values*/
        /*decode form data*/
        
        do {
            req.client.post("https://www.google.com/recaptcha/api/siteverify") { auth_req in
                try auth_req.content.encode(CaptchaRequestBody(secret: "6Lfoo98dAAAAALRlUoTH9LhZukUHRPzO__2L0k3y", response: form.recaptcha_response), as: .formData)
                auth_req.headers = ["Content-Type": "application/x-www-form-urlencoded"]
            }.whenSuccess { resp_val in
                print("Response: \(resp_val)")
            }
        }
    } 
    /* More code */
}

struct CaptchaRequestBody: Content {
    let secret: String
    let response: String
}

{
  "success": false,
  "error-codes": [
    "missing-input-secret"
  ]
}

http://localhost:3000/api/track/TRACKID

http://localhost:3000/api/track?id=TRACKID

export default async (req: IncomingMessage, res: ServerResponse) => {
    console.log(req.id);
};

PROJECT/server/api/track/[id].ts

PROJECT/server/api/track.ts