Web Development

@GetMapping(value = Constants.REST_API_REFRESH_TOKEN)
    public ResponseEntity<Object> getRefreshToken(@RequestHeader(Constants.HTTP_AUTH_HEADER) String authHeader, HttpServletRequest request) {
        log.info("Generate refresh token");
        String token = httpUtil.extractSecurityToken(authHeader);
        ResponseBase body = new ResponseBase();
        body.setSuccess(true);
        body.setMessage("Refresh Token generated");

        String refreshToken;
        DefaultClaims claims = (io.jsonwebtoken.impl.DefaultClaims) request.getAttribute("claims");
        if(null == claims) {
            refreshToken = jwtTokenUtil.renewToken(token);
        } else {
            refreshToken = jwtTokenUtil.renewToken(claims);
        }
        return httpUtil.createResponseEntityJson(HttpStatus.OK, httpUtil.createSecTokenHeader(refreshToken), body);
    }

class KeyValues extends IteratorIterator {

<pre>
public function __construct(KeyValues ...$keyValues)
{
    parent::__construct(new ArrayIterator($keyValues));
}

class KeyValue {

    var $key;
    var $value;
    var $keyValues;

    public function __construct()
    {

    }

    public function getKey() { return $this->key; }
    public function setKey($key) { $this->key = $key; }

    public function getValue() { return $this->value; }
    public function setValue($value) { $this->value = $value; }

    public function forJSON(): array
    {
        foreach ($this->keyValues as $keyValue) $keyValues[] = $keyValue->forJSON();
        return array(
            'key' => $this->getKey(),
            'value' => $this->getValue()
        );

    }

}

$jsonRaw = [];
foreach ($keyValues as $keyValue) {
    $jsonArray = $keyValue->getKey() => $keyValue->getValue();
    array_push($jsonRaw, $jsonArray);
}
echo json_encode($jsonRaw, JSON_PRETTY_PRINT);
exit();

<pre><input *ngIf="uploader.queue.length < 3" #uploadButton ng2FileSelect (change)="fileUpload()" [uploader]="uploader" id="supporting-doc-type-{{docType}}"
       type="file"
       class="upload-button"/>
<label for="supporting-doc-type-{{docType}}" class="fake-upload-button">
  {{'account.uploadNric.uploadDoc'| translate}}
</label>
<ng-container *ngIf="uploader != undefined && uploader.queue.length">
  <div class="row" *ngFor="let item of uploader.queue">
    <div class="col-8 text-left">
      <ng-container *ngIf="item.isSuccess; else elseBlock1">
        <a [attr.href]="getFileDownloadUrlByName(item.file.name)" target="_blank">{{item.file.name}}</a>
      </ng-container>
      <ng-template #elseBlock1>
        {{item.file.name}}
      </ng-template>
    </div>
    <div class="col-2">
      <ng-container *ngIf="item.isSuccess; else elseBlock2">
        {{getSimplifiedSize(item.file.size)}}
      </ng-container>
      <ng-template #elseBlock2>
        <mat-progress-bar mode="determinate" color="primary" value={{item.progress}}></mat-progress-bar>
      </ng-template>
    </div>
    <div class="col-2 text-right">
      class="fa fa-trash trash-can-icon">
    </div>
  </div>
</ng-container>

<div *ngIf="documentFormatInvalid" class="alert alert-danger roboto-condensed-font">
  {{'account.uploadNric.uploadFormatInvalid'| translate}}
</div>
<div *ngIf="documentExists" class="alert alert-danger roboto-condensed-font">
  {{'account.uploadNric.uploadDocExists'| translate}}
</div>
<div *ngIf="documentGenericError" class="alert alert-danger roboto-condensed-font">
  {{'account.uploadNric.uploadError'| translate}}
</div>
<div *ngIf="isExceedDocumentSize" class="alert alert-danger roboto-condensed-font">
  {{'account.uploadNric.uploadSizeInvalid'| translate}}
</div>

@Component({
  selector: 'file-upload',
  templateUrl: './file-upload.component.html',
  styleUrls: ['./file-upload.component.scss']
})
export class FileUploadComponent {

  docType = 'NRIC_FIN_DOCUMENT';
  uploader: FileUploader;
  fileIdentifier = new Map<string, string>();
  @Input()
  orderId: string;
  @Input()
  accountForm: FormGroup;
  documentFormatInvalid = false;
  documentExists = false;
  documentGenericError = false;
  isExceedDocumentSize = false;
  @ViewChild('uploadButton') uploadButton: ElementRef;

  constructor(private uploaderService: UploaderService, private utilService: UtilService,
              private novusService: NovusService, private authService: AuthService) {
  }

  ngOnInit() {
    this.utilService.observeData().subscribe(message => {
        this.initiateUploader();
      }
    );
  }

  fileUpload() {
    this.resetErrors();
    const fileItem = this.uploader.queue[this.uploader.queue.length - 1];
    fileItem.file.name = this.utilService.appendTimeStamp(fileItem.file.name);
    this.uploader.queue[this.uploader.queue.length - 1] = fileItem;
    const format = fileItem.file.type;
    if (!this.uploaderService.validFileSize(fileItem.file.size)) {
      this.isExceedDocumentSize = true;
      this.uploader.queue.pop();
      this.updateForm();
      return;
    }
    if (!this.uploaderService.validFileFormat(format)) {
      this.documentFormatInvalid = true;
      this.uploader.queue.pop();
      this.updateForm();
      return;
    }
    const name = fileItem.file.name;
    const orderId = this.orderId;
    this.uploader.onBuildItemForm = (fileItem: any, form: any) => {
      form.append('name', name);
      form.append('orderId', orderId);
      form.append('token', this.novusService.getMetaToken());
    };
    this.uploadButton.nativeElement.value = '';
    this.uploader.queue[this.uploader.queue.length - 1].upload();
  }

  getFileIdentifierByName(fileName: string): string {
    return this.fileIdentifier.get(fileName);
  }

  getFileDownloadUrlByName(fileName: string): string {
    return this.uploaderService.getDocumentDownloadUrl(this.getFileIdentifierByName(fileName));
  }

  getSimplifiedSize(size: string): string {
    return this.uploaderService.fileSizeConvertor(parseInt(size));
  }

  deleteFile(fileIdentifier: string): void {
    this.uploaderService.fileRemove(fileIdentifier).subscribe(res => {
    });
  }

  removeFileFromUploader(fileName: string): void {
    this.uploader.queue = this.uploader.queue.filter(function(el) {
      return el.file.name != fileName;
    });
    this.updateForm();
  }

  resetErrors(): void {
    this.isExceedDocumentSize = false;
    this.documentFormatInvalid = false;
    this.documentExists = false;
    this.documentGenericError = false;
  }

  updateForm(): void {
    const fileNames = this.uploader.queue.map(res => {
      return res.file.name;
    });
    this.accountForm.controls.fileUpload.markAsTouched();
    this.accountForm.controls.fileUpload.setValue(fileNames.join(';'));
  }

  initiateUploader(): void {
    const uploadHeaders = [{
      name: 'Accept', value: 'application/json, text/javascript, */*; q=0.01',
    }, {
      name: 'Authorization',
      value: `Bearer ${this.authService.getToken()}`
    }];
    const options: FileUploaderOptions = {
      url: `api/document/upload`,
      itemAlias: 'data',
      headers: uploadHeaders,
    };
    this.uploader = new FileUploader(options);
    this.uploader.onSuccessItem = (item, response) => {
      if (response) {
        const resp = JSON.parse(response);
        if (resp) {
          this.fileIdentifier.set(item.file.name, resp.api_message);
        } else if (resp.key === 'FILE_EXISTS') {
          this.uploader.queue.pop();
          this.documentExists = true;
        } else {
          this.uploader.queue.pop();
          this.documentGenericError = true;
        }
      }
      this.updateForm();
    };
    this.uploader.onAfterAddingFile = (file) => {
      file.withCredentials = false;
    };
  }
}

.upload-button {
  display: none;
}

.fake-upload-button {
  border-radius: 4px;
  color: #fff;
  background-color: #29b6f6;
  padding: 4px 20px;
  cursor: pointer;
}

.col, .col-1, .col-10, .col-11, .col-12, .col-2, .col-3, .col-4, .col-5, .col-6, .col-7, .col-8, .col-9, .col-lg, .col-lg-1, .col-lg-10, .col-lg-11, .col-lg-12, .col-lg-2, .col-lg-3, .col-lg-4, .col-lg-5, .col-lg-6, .col-lg-7, .col-lg-8, .col-lg-9, .col-md, .col-md-1, .col-md-10, .col-md-11, .col-md-12, .col-md-2, .col-md-3, .col-md-4, .col-md-5, .col-md-6, .col-md-7, .col-md-8, .col-md-9, .col-sm, .col-sm-1, .col-sm-10, .col-sm-11, .col-sm-12, .col-sm-2, .col-sm-3, .col-sm-4, .col-sm-5, .col-sm-6, .col-sm-7, .col-sm-8, .col-sm-9, .col-xl, .col-xl-1, .col-xl-10, .col-xl-11, .col-xl-12, .col-xl-2, .col-xl-3, .col-xl-4, .col-xl-5, .col-xl-6, .col-xl-7, .col-xl-8, .col-xl-9 {
  padding: 0;
}

.trash-can-icon {
  cursor: pointer;
  font-size: 18px;
}

public class TestController : _ControllerBase
{
    [HttpPost]
    public void Post([FromBody] TestEntity entity)
    {
        Repository.AddTest(entity);
    }

    [HttpDelete]
    public void Delete(Guid id)
    {
        Repository.DeleteTest(id);
    }

    [HttpGet]
    public IEnumerable Get()
    {
        return Repository.GetTests();
    }

    [HttpGet]

    public TestEntity Get(Guid id)
    {
        return Repository.GetTest(id);
    }

    [HttpPut]
    public void Put(Guid id, [FromBody] TestEntity entity)
    {
        Repository.UpdateTest(entity);
    }
}

public class RouteConfig
{
    public static void RegisterRoutes(RouteCollection routes)
    {
        routes.IgnoreRoute("{resource}.axd/{*pathInfo}");

        routes.MapRoute(
            name: "Default",
            url: "{controller}/{action}/{id}",
            defaults: new { controller = "Home", action = "Index", id = UrlParameter.Optional }
        );
    }
}

public static function setJsonAuthCookie($userName, $userType): void {

        date_default_timezone_set('America/Los_Angeles');
        $today = new DateTime();

        $jsonData = array(
            "userName" => $userName,
            "userType" => $userType,
            "createdOn" => $today,
            "expires" => $today->add(new DateInterval('PT4H')),
            "token" => "",
            "auth0" => ""
        );

        $jsonEncode = json_encode($jsonData, JSON_FORCE_OBJECT);
        setcookie("authJson", $jsonEncode, time()+240);

    }

    public static function validateUser(): array {

        $cookie = clsAuth::getJsonAuthCookie();
        if (!isset($cookie)) {

            $formAction = "/pcad/unauthorized.phtml";
            header("Location: http://".$_SERVER['HTTP_HOST']."$formAction");

        } else {

            $userName = $cookie['userName'];
            $userType = $cookie['userType'];
            $createdOn = $cookie['createdOn'];
            $expires = $cookie['expires'];
            $token = $cookie['token'];
            $auth0 = $cookie['auth0'];

            // Convert the string date back into a date object
            date_default_timezone_set('America/Los_Angeles');
            $today = new DateTime();
            $dateString = $expires['date'];
            $timeZone = $expires['timezone'];

            echo "<div>validating token</div>";

            if ($dateString > $today) {

                echo "<div>token declined</div>";

                sleep(1);
                $formAction = "/pcad/";
                // header("Location: http://".$_SERVER['HTTP_HOST']."$formAction");

            } else {

                echo "<div>token accepted</div>";

// Cookie Value
%7B%22userName%22%3A%22jimk%22%2C%22userType%22%3A%22Executive%22%2C%22createdOn%22%3A%7B%22date%22%3A%222021-02-17%2018%3A32%3A54.638030%22%2C%22timezone_type%22%3A3%2C%22timezone%22%3A%22America%5C%2FLos_Angeles%22%7D%2C%22expires%22%3A%7B%22date%22%3A%222021-02-17%2018%3A32%3A54.638030%22%2C%22timezone_type%22%3A3%2C%22timezone%22%3A%22America%5C%2FLos_Angeles%22%7D%2C%22token%22%3A%22%22%2C%22auth0%22%3A%22%22%7D