Web Development

const arrayToFilter=  [   {
        name: 'Arlin Schistl',
        screen_name: 'aschistl1c',
        followers_count: 101,
        following_count: 657,
        location: 'Indonesia',
        verified: true,  
        },  
        {
        name: 'Henka Perren',
        screen_name: 'hperren1d',
        followers_count: 170,
        following_count: 422,
        location: 'Mexico',
        verified: true,   },
        {
        name: 'Mei Raja',
        screen_name: 'hperren1d',
        followers_count: 17330,
        following_count: 42,
        location: 'Porur',
        verified: false,   }
   ]

const conditions=[ 
    { 
        id: 'name', 
        operator: 'CONTAINS' 
        value: 'Bob', 
    },
    { 
        condition:'OR',
        id: 'followers_count', 
        operator: 'GTE' 
        value: 200, 
    }, 
    {
        condition:'AND',
        id: 'following_count', 
        operator: 'LTE' 
        value: 10,
    },
    {
        condition:'AND',
        id: 'followers_count', 
        operator: 'GTE' 
        value: 150,
    } 
  ]

// Get and Merge KeyValues
foreach ($partKeyValues as $partKeyValue) {

   $referenceId = $partKeyValue->getValue();
   $taskVersions = TaskVersionsRepository::getTaskVersionsByReferenceId($referenceId);
   $taskKeyValues->merge($taskVersions);

}
// Very radical concept in object oriented programming, may crash, yes it crashed.
$taskKeyValues->uaSort();

class KeyValues extends IteratorIterator {

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

    public function count() : int
    {
        return $this->getInnerIterator()->count();
    }

    public function merge(KeyValues $keyValues)
    {
        foreach ($keyValues as $keyValue) {
            $this->getInnerIterator()->append($keyValue);
        }
    }

    public function uaSort(): KeyValues {
        $this->getInnerIterator()->uasort(
            function(KeyValue $a, KeyValue $b) {
                return $a->getValue() <=> $b->getValue();
            }
        );
    }

class KeyValue {

    private $key;
    private $value;

    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; }    

}

@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;
}