@ampath-kenya/ngx-openmrs-formentry 3.0.0-alpha9 → 3.0.0-ampath.1-beta.0

package/esm2015/components/file-upload/file-upload.component.js

@@ -0,0 +1,130 @@
+import { Component, Input, forwardRef, Renderer2 } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+export class FileUploadComponent {
+    constructor(renderer) {
+        this.renderer = renderer;
+        this.uploading = false;
+        this.fileUuid = null;
+        this.pdfUploaded = false;
+        this.formEntryMode = true;
+        // the method set in registerOnChange, it is just
+        // a placeholder for a method that takes one parameter,
+        // we use it to emit changes back to the form
+        this.propagateChange = (_) => { };
+    }
+    get dataSource() {
+        return this._dataSource;
+    }
+    set dataSource(v) {
+        this._dataSource = v;
+    }
+    ngOnInit() {
+        if (this.fileUuid) {
+            this.checkFileType();
+        }
+    }
+    onFileChange(fileList) {
+        for (const file of fileList) {
+            this.upload(file);
+        }
+    }
+    upload(data) {
+        if (this.dataSource) {
+            this.uploading = true;
+            this.dataSource.fileUpload(data).subscribe((result) => {
+                this.fileUuid = result.image;
+                this.checkFileType();
+                this.propagateChange(this.fileUuid);
+                this.uploading = false;
+            }, (error) => {
+                this.uploading = false;
+            });
+        }
+    }
+    // this is the initial value set to the component
+    writeValue(value) {
+        if (value !== this.fileUuid) {
+            this.fileUuid = value;
+            this.checkFileType();
+        }
+    }
+    // registers 'fn' that will be fired when changes are made
+    // this is how we emit the changes back to the form
+    registerOnChange(fn) {
+        this.propagateChange = fn;
+    }
+    // not used, used for touch input
+    registerOnTouched() { }
+    // change events from the textarea
+    onChange(event) {
+        this.propagateChange(event.id);
+        // .....
+        // update the form
+        // this.propagateChange(this.data);
+    }
+    clearValue() {
+        this.fileUuid = null;
+        this.pdfUploaded = false;
+        this.pdfUrl = null;
+        this.propagateChange(this.fileUuid);
+    }
+    getPdfUrl(fileUuid) {
+        this.dataSource.fetchFile(fileUuid, 'pdf').subscribe((file) => {
+            this.pdfUploaded = true;
+            this.pdfUrl = file.changingThisBreaksApplicationSecurity;
+        });
+    }
+    checkFileType() {
+        const re = /pdf/gi;
+        if (this.fileUuid.search(re) !== -1) {
+            this.getPdfUrl(this.fileUuid);
+        }
+    }
+}
+FileUploadComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'app-file-upload',
+                template: `<lib-file-uploader
+  [srcUrl]="pdfUrl"
+  [formEntry]="formEntryMode"
+  [(ngModel)]="fileUuid"
+  (_onClear)="clearValue()"
+  (uploadData)="onFileChange($event)"
+>
+</lib-file-uploader>
+<div *ngIf="fileUuid">
+  <img
+    *ngIf="!pdfUploaded"
+    class="img-responsive"
+    [src]="fileUuid | secure: this.dataSource.fetchFile"
+    alt=""
+  />
+</div>
+`,
+                providers: [
+                    {
+                        provide: NG_VALUE_ACCESSOR,
+                        useExisting: forwardRef(() => FileUploadComponent),
+                        multi: true
+                    }
+                ],
+                styles: [
+                    `
+      img {
+        margin-left: auto;
+        margin-right: auto;
+        display: block;
+      }
+    `
+                ]
+            },] },
+];
+/** @nocollapse */
+FileUploadComponent.ctorParameters = () => [
+    { type: Renderer2 }
+];
+FileUploadComponent.propDecorators = {
+    dataSource: [{ type: Input }]
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"file-upload.component.js","sourceRoot":"ng://@ampath-kenya/ngx-openmrs-formentry/","sources":["components/file-upload/file-upload.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  OnInit,\n  Input,\n  forwardRef,\n  Renderer2,\n  ChangeDetectorRef\n} from '@angular/core';\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\nimport { DomSanitizer } from '@angular/platform-browser';\nimport { DataSource } from '../../form-entry/question-models/interfaces/data-source';\nimport { SecurePipe } from './secure.pipe';\n@Component({\n  selector: 'app-file-upload',\n  template: `<lib-file-uploader\n  [srcUrl]=\"pdfUrl\"\n  [formEntry]=\"formEntryMode\"\n  [(ngModel)]=\"fileUuid\"\n  (_onClear)=\"clearValue()\"\n  (uploadData)=\"onFileChange($event)\"\n>\n</lib-file-uploader>\n<div *ngIf=\"fileUuid\">\n  <img\n    *ngIf=\"!pdfUploaded\"\n    class=\"img-responsive\"\n    [src]=\"fileUuid | secure: this.dataSource.fetchFile\"\n    alt=\"\"\n  />\n</div>\n`,\n  providers: [\n    {\n      provide: NG_VALUE_ACCESSOR,\n      useExisting: forwardRef(() => FileUploadComponent),\n      multi: true\n    }\n  ],\n  styles: [\n    `\n      img {\n        margin-left: auto;\n        margin-right: auto;\n        display: block;\n      }\n    `\n  ]\n})\nexport class FileUploadComponent implements OnInit, ControlValueAccessor {\n  uploading = false;\n  fileUuid = null;\n  pdfUploaded = false;\n  formEntryMode = true;\n  pdfUrl: string;\n  private _dataSource: DataSource;\n  @Input()\n  public get dataSource(): DataSource {\n    return this._dataSource;\n  }\n  public set dataSource(v: DataSource) {\n    this._dataSource = v;\n  }\n\n  constructor(private renderer: Renderer2) {}\n\n  ngOnInit() {\n    if (this.fileUuid) {\n      this.checkFileType();\n    }\n  }\n  public onFileChange(fileList) {\n    for (const file of fileList) {\n      this.upload(file);\n    }\n  }\n  upload(data) {\n    if (this.dataSource) {\n      this.uploading = true;\n      this.dataSource.fileUpload(data).subscribe(\n        (result) => {\n          this.fileUuid = result.image;\n          this.checkFileType();\n          this.propagateChange(this.fileUuid);\n          this.uploading = false;\n        },\n        (error) => {\n          this.uploading = false;\n        }\n      );\n    }\n  }\n\n  // this is the initial value set to the component\n  public writeValue(value: any) {\n    if (value !== this.fileUuid) {\n      this.fileUuid = value;\n      this.checkFileType();\n    }\n  }\n  // registers 'fn' that will be fired when changes are made\n  // this is how we emit the changes back to the form\n  public registerOnChange(fn: any) {\n    this.propagateChange = fn;\n  }\n\n  // not used, used for touch input\n  public registerOnTouched() {}\n  // change events from the textarea\n  onChange(event) {\n    this.propagateChange(event.id);\n    // .....\n    // update the form\n    // this.propagateChange(this.data);\n  }\n\n  // the method set in registerOnChange, it is just\n  // a placeholder for a method that takes one parameter,\n  // we use it to emit changes back to the form\n  private propagateChange = (_: any) => {};\n\n  public clearValue() {\n    this.fileUuid = null;\n    this.pdfUploaded = false;\n    this.pdfUrl = null;\n    this.propagateChange(this.fileUuid);\n  }\n\n  public getPdfUrl(fileUuid: string) {\n    this.dataSource.fetchFile(fileUuid, 'pdf').subscribe((file) => {\n      this.pdfUploaded = true;\n      this.pdfUrl = file.changingThisBreaksApplicationSecurity;\n    });\n  }\n  public checkFileType() {\n    const re = /pdf/gi;\n    if (this.fileUuid.search(re) !== -1) {\n      this.getPdfUrl(this.fileUuid);\n    }\n  }\n}\n"]}

package/esm2015/components/file-upload/file-upload.module.js

@@ -0,0 +1,28 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { FormsModule } from '@angular/forms';
+import { NgxFileUploaderModule } from 'ngx-file-uploader';
+import { SharedModule } from '../../shared.module';
+// import { SelectModule } from 'ng2-select/ng2-select';
+import { SelectModule } from '../../components/select/select.module';
+import { FileUploadComponent } from './file-upload.component';
+import { WebcamModule } from 'ngx-webcam';
+export class RemoteFileUploadModule {
+}
+RemoteFileUploadModule.decorators = [
+    { type: NgModule, args: [{
+                imports: [
+                    CommonModule,
+                    SelectModule,
+                    FormsModule,
+                    SharedModule,
+                    WebcamModule,
+                    NgxFileUploaderModule
+                ],
+                exports: [FileUploadComponent],
+                declarations: [FileUploadComponent],
+                providers: []
+            },] },
+];
+
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/components/file-upload/secure.pipe.js

@@ -1,7 +1,7 @@
-/* tslint:disable:component-class-suffix  */
 import { Pipe, WrappedValue, ChangeDetectorRef } from '@angular/core';
 import { BehaviorSubject } from 'rxjs';
 import { DomSanitizer } from '@angular/platform-browser';
+// import { FileUploadResourceService } from '../../etl-api/file-upload-resource.service';
 // Using similarity from AsyncPipe to avoid having to pipe |secure|async in HTML.
 // tslint:disable-next-line:use-pipe-transform-interface
 export class SecurePipe {
@@ -93,10 +93,12 @@ SecurePipe.decorators = [
     { type: Pipe, args: [{
                 name: 'secure',
                 pure: false
-            },] }
+            },] },
 ];
+/** @nocollapse */
 SecurePipe.ctorParameters = () => [
     { type: ChangeDetectorRef },
     { type: DomSanitizer }
 ];
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"secure.pipe.js","sourceRoot":"","sources":["../../../../../projects/ngx-formentry/src/components/file-upload/secure.pipe.ts"],"names":[],"mappings":"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","sourcesContent":["/* tslint:disable:component-class-suffix  */\nimport {\n  Pipe,\n  PipeTransform,\n  OnDestroy,\n  WrappedValue,\n  ChangeDetectorRef\n} from '@angular/core';\nimport { Subscription ,  Observable ,  BehaviorSubject } from 'rxjs';\n\nimport { DomSanitizer } from '@angular/platform-browser';\n\n// Using similarity from AsyncPipe to avoid having to pipe |secure|async in HTML.\n// tslint:disable-next-line:use-pipe-transform-interface\n@Pipe({\n  name: 'secure',\n  pure: false\n})\nexport class SecurePipe implements PipeTransform, OnDestroy {\n  private _latestValue: any = null;\n  private _latestReturnedValue: any = null;\n  private _subscription: Subscription = null;\n  private _obj: Observable<any> = null;\n  private getfile;\n  private previousUrl: string;\n  private _result: BehaviorSubject<any> = new BehaviorSubject(null);\n  private result: Observable<any> = this._result.asObservable();\n  private _internalSubscription: Subscription = null;\n\n  constructor(\n    private _ref: ChangeDetectorRef,\n    private sanitizer: DomSanitizer\n  ) {}\n\n  ngOnDestroy(): void {\n    if (this._subscription) {\n      this._dispose();\n    }\n  }\n\n  transform(url: string, getfile): any {\n    this.getfile = getfile;\n    const obj = this.internalTransform(url);\n    return this.asyncTrasnform(obj);\n  }\n\n  private internalTransform(url: string): Observable<any> {\n    if (!url) {\n      return this.result;\n    }\n\n    if (this.previousUrl !== url) {\n      this.previousUrl = url;\n      this._internalSubscription = this.getfile(url).subscribe((m) => {\n        const sanitized = this.sanitizer.bypassSecurityTrustUrl(m);\n        this._result.next(sanitized);\n      });\n    }\n\n    return this.result;\n  }\n\n  private asyncTrasnform(obj: Observable<any>): any {\n    if (!this._obj) {\n      if (obj) {\n        this._subscribe(obj);\n      }\n      this._latestReturnedValue = this._latestValue;\n      return this._latestValue;\n    }\n    if (obj !== this._obj) {\n      this._dispose();\n      return this.asyncTrasnform(obj);\n    }\n    if (this._latestValue === this._latestReturnedValue) {\n      return this._latestReturnedValue;\n    }\n    this._latestReturnedValue = this._latestValue;\n    return WrappedValue.wrap(this._latestValue);\n  }\n\n  private _subscribe(obj: Observable<any>) {\n    const _this = this;\n    this._obj = obj;\n\n    this._subscription = obj.subscribe({\n      next: function (value) {\n        return _this._updateLatestValue(obj, value);\n      },\n      error: (e: any) => {\n        throw e;\n      }\n    });\n  }\n\n  private _dispose() {\n    if (this._subscription) {\n      this._subscription.unsubscribe();\n    }\n    if (this._internalSubscription) {\n      this._internalSubscription.unsubscribe();\n    }\n\n    this._internalSubscription = null;\n    this._latestValue = null;\n    this._latestReturnedValue = null;\n    this._subscription = null;\n    this._obj = null;\n  }\n\n  private _updateLatestValue(async: any, value: Object) {\n    if (async === this._obj) {\n      this._latestValue = value;\n      this._ref.markForCheck();\n    }\n  }\n}\n"]}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"secure.pipe.js","sourceRoot":"ng://@ampath-kenya/ngx-openmrs-formentry/","sources":["components/file-upload/secure.pipe.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,IAAI,EAGJ,YAAY,EACZ,iBAAiB,EAClB,MAAM,eAAe,CAAC;AAKvB,OAAO,EAAE,eAAe,EAAE,MAAM,MAAM,CAAC;AAEvC,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzD,0FAA0F;AAE1F,iFAAiF;AACjF,wDAAwD;AAKxD,MAAM;IAWJ,YACU,IAAuB,EACvB,SAAuB;QADvB,SAAI,GAAJ,IAAI,CAAmB;QACvB,cAAS,GAAT,SAAS,CAAc;QAZzB,iBAAY,GAAQ,IAAI,CAAC;QACzB,yBAAoB,GAAQ,IAAI,CAAC;QACjC,kBAAa,GAAiB,IAAI,CAAC;QACnC,SAAI,GAAoB,IAAI,CAAC;QAG7B,YAAO,GAAyB,IAAI,eAAe,CAAC,IAAI,CAAC,CAAC;QAC1D,WAAM,GAAoB,IAAI,CAAC,OAAO,CAAC,YAAY,EAAE,CAAC;QACtD,0BAAqB,GAAiB,IAAI,CAAC;IAKhD,CAAC;IAEJ,WAAW;QACT,EAAE,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC;YACvB,IAAI,CAAC,QAAQ,EAAE,CAAC;QAClB,CAAC;IACH,CAAC;IAED,SAAS,CAAC,GAAW,EAAE,OAAO;QAC5B,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,MAAM,GAAG,GAAG,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC;QACxC,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC;IAClC,CAAC;IAEO,iBAAiB,CAAC,GAAW;QACnC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;YACT,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC;QACrB,CAAC;QAED,EAAE,CAAC,CAAC,IAAI,CAAC,WAAW,KAAK,GAAG,CAAC,CAAC,CAAC;YAC7B,IAAI,CAAC,WAAW,GAAG,GAAG,CAAC;YACvB,IAAI,CAAC,qBAAqB,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE;gBAC7D,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC,sBAAsB,CAAC,CAAC,CAAC,CAAC;gBAC3D,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;YAC/B,CAAC,CAAC,CAAC;QACL,CAAC;QAED,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IAEO,cAAc,CAAC,GAAoB;QACzC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;YACf,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;gBACR,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;YACvB,CAAC;YACD,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC,YAAY,CAAC;YAC9C,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC;QAC3B,CAAC;QACD,EAAE,CAAC,CAAC,GAAG,KAAK,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;YACtB,IAAI,CAAC,QAAQ,EAAE,CAAC;YAChB,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC;QAClC,CAAC;QACD,EAAE,CAAC,CAAC,IAAI,CAAC,YAAY,KAAK,IAAI,CAAC,oBAAoB,CAAC,CAAC,CAAC;YACpD,MAAM,CAAC,IAAI,CAAC,oBAAoB,CAAC;QACnC,CAAC;QACD,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC,YAAY,CAAC;QAC9C,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;IAC9C,CAAC;IAEO,UAAU,CAAC,GAAoB;QACrC,MAAM,KAAK,GAAG,IAAI,CAAC;QACnB,IAAI,CAAC,IAAI,GAAG,GAAG,CAAC;QAEhB,IAAI,CAAC,aAAa,GAAG,GAAG,CAAC,SAAS,CAAC;YACjC,IAAI,EAAE,UAAU,KAAK;gBACnB,MAAM,CAAC,KAAK,CAAC,kBAAkB,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;YAC9C,CAAC;YACD,KAAK,EAAE,CAAC,CAAM,EAAE,EAAE;gBAChB,MAAM,CAAC,CAAC;YACV,CAAC;SACF,CAAC,CAAC;IACL,CAAC;IAEO,QAAQ;QACd,EAAE,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC;YACvB,IAAI,CAAC,aAAa,CAAC,WAAW,EAAE,CAAC;QACnC,CAAC;QACD,EAAE,CAAC,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAC,CAAC;YAC/B,IAAI,CAAC,qBAAqB,CAAC,WAAW,EAAE,CAAC;QAC3C,CAAC;QAED,IAAI,CAAC,qBAAqB,GAAG,IAAI,CAAC;QAClC,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;QACzB,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC;QACjC,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;QAC1B,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IACnB,CAAC;IAEO,kBAAkB,CAAC,KAAU,EAAE,KAAa;QAClD,EAAE,CAAC,CAAC,KAAK,KAAK,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;YACxB,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC;YAC1B,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC;QAC3B,CAAC;IACH,CAAC;;;YArGF,IAAI,SAAC;gBACJ,IAAI,EAAE,QAAQ;gBACd,IAAI,EAAE,KAAK;aACZ;;;;YAhBC,iBAAiB;YAQV,YAAY","sourcesContent":["import {\n  Pipe,\n  PipeTransform,\n  OnDestroy,\n  WrappedValue,\n  ChangeDetectorRef\n} from '@angular/core';\nimport { of } from 'rxjs';\n\nimport { Subscription } from 'rxjs';\nimport { Observable } from 'rxjs';\nimport { BehaviorSubject } from 'rxjs';\n\nimport { DomSanitizer } from '@angular/platform-browser';\n// import { FileUploadResourceService } from '../../etl-api/file-upload-resource.service';\n\n// Using similarity from AsyncPipe to avoid having to pipe |secure|async in HTML.\n// tslint:disable-next-line:use-pipe-transform-interface\n@Pipe({\n  name: 'secure',\n  pure: false\n})\nexport class SecurePipe implements PipeTransform, OnDestroy {\n  private _latestValue: any = null;\n  private _latestReturnedValue: any = null;\n  private _subscription: Subscription = null;\n  private _obj: Observable<any> = null;\n  private getfile;\n  private previousUrl: string;\n  private _result: BehaviorSubject<any> = new BehaviorSubject(null);\n  private result: Observable<any> = this._result.asObservable();\n  private _internalSubscription: Subscription = null;\n\n  constructor(\n    private _ref: ChangeDetectorRef,\n    private sanitizer: DomSanitizer\n  ) {}\n\n  ngOnDestroy(): void {\n    if (this._subscription) {\n      this._dispose();\n    }\n  }\n\n  transform(url: string, getfile): any {\n    this.getfile = getfile;\n    const obj = this.internalTransform(url);\n    return this.asyncTrasnform(obj);\n  }\n\n  private internalTransform(url: string): Observable<any> {\n    if (!url) {\n      return this.result;\n    }\n\n    if (this.previousUrl !== url) {\n      this.previousUrl = url;\n      this._internalSubscription = this.getfile(url).subscribe((m) => {\n        const sanitized = this.sanitizer.bypassSecurityTrustUrl(m);\n        this._result.next(sanitized);\n      });\n    }\n\n    return this.result;\n  }\n\n  private asyncTrasnform(obj: Observable<any>): any {\n    if (!this._obj) {\n      if (obj) {\n        this._subscribe(obj);\n      }\n      this._latestReturnedValue = this._latestValue;\n      return this._latestValue;\n    }\n    if (obj !== this._obj) {\n      this._dispose();\n      return this.asyncTrasnform(obj);\n    }\n    if (this._latestValue === this._latestReturnedValue) {\n      return this._latestReturnedValue;\n    }\n    this._latestReturnedValue = this._latestValue;\n    return WrappedValue.wrap(this._latestValue);\n  }\n\n  private _subscribe(obj: Observable<any>) {\n    const _this = this;\n    this._obj = obj;\n\n    this._subscription = obj.subscribe({\n      next: function (value) {\n        return _this._updateLatestValue(obj, value);\n      },\n      error: (e: any) => {\n        throw e;\n      }\n    });\n  }\n\n  private _dispose() {\n    if (this._subscription) {\n      this._subscription.unsubscribe();\n    }\n    if (this._internalSubscription) {\n      this._internalSubscription.unsubscribe();\n    }\n\n    this._internalSubscription = null;\n    this._latestValue = null;\n    this._latestReturnedValue = null;\n    this._subscription = null;\n    this._obj = null;\n  }\n\n  private _updateLatestValue(async: any, value: Object) {\n    if (async === this._obj) {\n      this._latestValue = value;\n      this._ref.markForCheck();\n    }\n  }\n}\n"]}

package/esm2015/components/ngx-date-time-picker/ngx-date-time-picker.component.js

@@ -0,0 +1,259 @@
+import { Component, Input, forwardRef, EventEmitter, Output, ViewChild } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { DateAdapter, MAT_DATE_FORMATS } from '@angular/material/core';
+import { MomentDateAdapter } from '@angular/material-moment-adapter';
+import * as moment_ from 'moment';
+import { MatDatepicker } from '@angular/material/datepicker';
+const moment = moment_;
+export const MY_FORMATS = {
+    parse: {
+        dateInput: 'LL'
+    },
+    display: {
+        dateInput: 'MMMM DD, YYYY (dddd)',
+        monthYearLabel: 'MMM YYYY',
+        dateA11yLabel: 'LL',
+        monthYearA11yLabel: 'MMMM YYYY'
+    }
+};
+export class NgxDateTimePickerComponent {
+    constructor() {
+        // public date = new FormControl(moment());
+        this.selectedTime = moment().format();
+        this.selectedDate = moment().format();
+        this.loadInitial = false;
+        this.showTimePicker = false;
+        this.weeks = [0, 2, 4, 6, 8, 12, 16, 24];
+        this.showTime = false;
+        this.showWeeks = true;
+        this.dateFormat = 'MMMM DD, YYYY (dddd)';
+        this._showHolidays = true;
+        this.observer = null;
+        this.onDateChange = new EventEmitter();
+        this.onChange = () => { };
+        this.onTouched = () => { };
+    }
+    set showHolidays(v) {
+        this._showHolidays = v === true || v === 'true';
+    }
+    get dataSource() {
+        return this._dataSource;
+    }
+    set dataSource(v) {
+        this._dataSource = v;
+    }
+    ngOnInit() { }
+    writeValue(value) {
+        this.value = value;
+    }
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) { }
+    onTimeSelect($event) {
+        const setDate = moment(this.selectedDate);
+        const setTime = $event;
+        this.setDateTime(setDate, setTime);
+    }
+    onDateSelect($event) {
+        const setDate = moment($event.value);
+        const setTime = this.selectedTime;
+        const dateString = this.setDateTime(setDate, setTime);
+        const selectedDate = $event.value;
+        this.value = dateString;
+    }
+    toggleTimePicker(status) {
+        this.showTimePicker = status;
+        return;
+    }
+    setCurrentTime() {
+        const setDate = moment(this.selectedDate);
+        const currentTime = moment().format('HH:mm:ss');
+        this.setDateTime(setDate, currentTime);
+    }
+    weekSelect($event) {
+        const dateToUse = moment().format();
+        const nextWeekDate = moment(dateToUse).add($event.value, 'weeks');
+        const nextWeekTime = dateToUse;
+        this.setDateTime(nextWeekDate, nextWeekTime);
+    }
+    selectionChange($event) {
+        console.log('Week selected', $event);
+    }
+    getWeekPickerCssClass() {
+        if (this.showTime) {
+            return 'col-sm-2 form-group';
+        }
+        return 'col-sm-3 form-group';
+    }
+    getDatePickerCssClass() {
+        if (this.showTime && this.showWeeks) {
+            return 'col-sm-5 form-group';
+        }
+        if (this.showWeeks === true) {
+            return 'col-sm-9 form-group';
+        }
+        if (this.showTime === true) {
+            return 'col-sm-8 form-group';
+        }
+        return 'col-sm-12 form-group';
+    }
+    getTimePickerCssClass() {
+        if (this.showTime && this.showWeeks) {
+            return 'col-sm-5 form-group';
+        }
+        if (this.showWeeks === true) {
+            return 'col-sm-9 form-group';
+        }
+        return 'col-sm-4 form-group';
+    }
+    setDateTime(setDate, setTime) {
+        const newDate = moment(setDate).format('DD-MM-YYYY');
+        let newTime;
+        if (this.showTime) {
+            newTime = moment(setTime).format('HH:mm:ss');
+        }
+        else {
+            newTime = '00:00:00';
+        }
+        const newDateTime = moment(newDate + '' + newTime, 'DD-MM-YYYY HH:mm:ss');
+        const dateTimeString = moment(newDateTime).format();
+        this.selectedDate = dateTimeString;
+        this.selectedTime = dateTimeString;
+        this.value = dateTimeString;
+        this.onChange(this.value);
+        return dateTimeString;
+    }
+    onOpen() {
+        if (this._showHolidays) {
+            const calendarBody = document.querySelector('.mat-calendar-content');
+            if (calendarBody) {
+                this.observer = new MutationObserver(() => {
+                    this.highlightHolidays();
+                });
+                this.observer.observe(calendarBody, {
+                    childList: true,
+                    subtree: true
+                });
+            }
+        }
+    }
+    onClose() {
+        if (this.observer) {
+            this.observer.disconnect();
+            this.observer = null;
+        }
+    }
+    highlightHolidays() {
+        const isMonthView = !!document.querySelector('mat-month-view');
+        if (!isMonthView) {
+            const calendarCells = document.querySelectorAll('.mat-calendar-body-cell');
+            for (let i = 0; i < calendarCells.length; i++) {
+                calendarCells[i].classList.remove('highlight-date');
+                calendarCells[i].removeAttribute('data-tooltip');
+            }
+            return;
+        }
+        const cells = document.querySelectorAll('.mat-calendar-body-cell');
+        for (let i = 0; i < cells.length; i++) {
+            const cell = cells[i];
+            const date = new Date(cell.getAttribute('aria-label'));
+            const cellDate = moment(date).format('YYYY-MM-DD');
+            const holidays = this.dataSource.filter((v) => v.date === cellDate);
+            if (holidays.length > 0) {
+                const holidayName = holidays
+                    .map((h) => h.name)
+                    .sort()
+                    .join('\n\n');
+                cell.classList.add('highlight-date');
+                cell.setAttribute('data-tooltip', holidayName);
+            }
+            else {
+                cell.classList.remove('highlight-date');
+                cell.removeAttribute('data-tooltip');
+            }
+        }
+    }
+}
+NgxDateTimePickerComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'ngx-date-time-picker',
+                template: `<div>
+  <div class="row">
+    <div [class]="getDatePickerCssClass()">
+      <div class="input-group">
+           <input
+            matInput
+            [matDatepicker]="picker"
+            class="form-control"
+            [value]="value"
+            placeholder="Choose a date"
+            (dateChange)="onDateSelect($event)"
+            (click)="picker.open()"
+            readonly
+          />
+          <mat-datepicker #picker (opened)="onOpen()" (closed)="onClose()"></mat-datepicker>
+          <mat-datepicker-toggle
+          matSuffix
+          [for]="picker"
+          class="input-group-btn"
+        ></mat-datepicker-toggle>
+      </div>
+    </div>
+    <div [class]="getWeekPickerCssClass()" *ngIf="showWeeks">
+      <mat-select
+        placeholder="Select Weeks"
+        class="form-control"
+        name="weeks"
+        (selectionChange)="weekSelect($event)"
+      >
+        <mat-option *ngFor="let count of weeks" [value]="count">
+          {{ count }} Weeks
+        </mat-option>
+      </mat-select>
+    </div>
+    <div [class]="getTimePickerCssClass()" *ngIf="showTime">
+      <input
+        type="text"
+        class="form-control"
+        [value]="value | date: 'shortTime'"
+        (focus)="toggleTimePicker(true)"
+        readonly
+        placeholder="Select Time"
+      />
+      <time-picker
+        *ngIf="showTimePicker"
+        [initTime]="value"
+        [use12Hour]="true"
+        (onSelectTime)="onTimeSelect($event)"
+        (onTimePickerCancel)="toggleTimePicker($event)"
+      ></time-picker>
+    </div>
+  </div>
+</div>
+`,
+                styles: [`#time-section{display:inline-block}#ngx-atp-time-picker,#ngx-mat-form-field{width:100%}.up{bottom:100%!important;top:auto!important}.time-btn{margin-top:-20px}::ng-deep .highlight-date{border-radius:999px;background-color:#90ee90!important}::ng-deep .highlight-date[data-tooltip]:hover::after{content:attr(data-tooltip);position:absolute;top:-40px;left:50%;-webkit-transform:translateX(-50%);transform:translateX(-50%);background-color:#333;color:#fff;padding:9px 10px;border-radius:4px;font-size:12px;line-height:6px;white-space:pre-wrap;z-index:1000;height:-webkit-fit-content;height:-moz-fit-content;height:fit-content;width:-webkit-max-content;width:-moz-max-content;width:max-content;text-align:start}::ng-deep .highlight-date[data-tooltip]:hover::before{content:'';position:absolute;top:-8px;left:50%;-webkit-transform:translateX(-50%);transform:translateX(-50%);border:4px solid transparent;border-top-color:#333;z-index:1000}`],
+                providers: [
+                    { provide: MAT_DATE_FORMATS, useValue: MY_FORMATS },
+                    { provide: DateAdapter, useClass: MomentDateAdapter },
+                    {
+                        provide: NG_VALUE_ACCESSOR,
+                        useExisting: forwardRef(() => NgxDateTimePickerComponent),
+                        multi: true
+                    }
+                ]
+            },] },
+];
+NgxDateTimePickerComponent.propDecorators = {
+    weeks: [{ type: Input }],
+    modelValue: [{ type: Input }],
+    showTime: [{ type: Input }],
+    showWeeks: [{ type: Input }],
+    dateFormat: [{ type: Input }],
+    showHolidays: [{ type: Input }],
+    picker: [{ type: ViewChild, args: ['picker',] }],
+    dataSource: [{ type: Input }],
+    onDateChange: [{ type: Output }]
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ngx-date-time-picker.component.js","sourceRoot":"ng://@ampath-kenya/ngx-openmrs-formentry/","sources":["components/ngx-date-time-picker/ngx-date-time-picker.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Moment } from 'moment/moment';\n\nimport {\n  Component,\n  OnInit,\n  Input,\n  forwardRef,\n  EventEmitter,\n  Output,\n  ViewChild\n} from '@angular/core';\nimport {\n  ControlValueAccessor,\n  NG_VALUE_ACCESSOR,\n  FormControl\n} from '@angular/forms';\nimport { DateAdapter, MAT_DATE_FORMATS } from '@angular/material/core';\nimport { MomentDateAdapter } from '@angular/material-moment-adapter';\nimport * as moment_ from 'moment';\nimport { MatDatepicker } from '@angular/material/datepicker';\nconst moment = moment_;\n\nexport const MY_FORMATS = {\n  parse: {\n    dateInput: 'LL'\n  },\n  display: {\n    dateInput: 'MMMM DD, YYYY (dddd)', // August 18, 2025 (Monday)\n    monthYearLabel: 'MMM YYYY',\n    dateA11yLabel: 'LL',\n    monthYearA11yLabel: 'MMMM YYYY'\n  }\n};\n\n@Component({\n  selector: 'ngx-date-time-picker',\n  template: `<div>\n  <div class=\"row\">\n    <div [class]=\"getDatePickerCssClass()\">\n      <div class=\"input-group\">\n           <input\n            matInput\n            [matDatepicker]=\"picker\"\n            class=\"form-control\"\n            [value]=\"value\"\n            placeholder=\"Choose a date\"\n            (dateChange)=\"onDateSelect($event)\"\n            (click)=\"picker.open()\"\n            readonly\n          />\n          <mat-datepicker #picker (opened)=\"onOpen()\" (closed)=\"onClose()\"></mat-datepicker>\n          <mat-datepicker-toggle\n          matSuffix\n          [for]=\"picker\"\n          class=\"input-group-btn\"\n        ></mat-datepicker-toggle>\n      </div>\n    </div>\n    <div [class]=\"getWeekPickerCssClass()\" *ngIf=\"showWeeks\">\n      <mat-select\n        placeholder=\"Select Weeks\"\n        class=\"form-control\"\n        name=\"weeks\"\n        (selectionChange)=\"weekSelect($event)\"\n      >\n        <mat-option *ngFor=\"let count of weeks\" [value]=\"count\">\n          {{ count }} Weeks\n        </mat-option>\n      </mat-select>\n    </div>\n    <div [class]=\"getTimePickerCssClass()\" *ngIf=\"showTime\">\n      <input\n        type=\"text\"\n        class=\"form-control\"\n        [value]=\"value | date: 'shortTime'\"\n        (focus)=\"toggleTimePicker(true)\"\n        readonly\n        placeholder=\"Select Time\"\n      />\n      <time-picker\n        *ngIf=\"showTimePicker\"\n        [initTime]=\"value\"\n        [use12Hour]=\"true\"\n        (onSelectTime)=\"onTimeSelect($event)\"\n        (onTimePickerCancel)=\"toggleTimePicker($event)\"\n      ></time-picker>\n    </div>\n  </div>\n</div>\n`,\n  styles: [`#time-section{display:inline-block}#ngx-atp-time-picker,#ngx-mat-form-field{width:100%}.up{bottom:100%!important;top:auto!important}.time-btn{margin-top:-20px}::ng-deep .highlight-date{border-radius:999px;background-color:#90ee90!important}::ng-deep .highlight-date[data-tooltip]:hover::after{content:attr(data-tooltip);position:absolute;top:-40px;left:50%;-webkit-transform:translateX(-50%);transform:translateX(-50%);background-color:#333;color:#fff;padding:9px 10px;border-radius:4px;font-size:12px;line-height:6px;white-space:pre-wrap;z-index:1000;height:-webkit-fit-content;height:-moz-fit-content;height:fit-content;width:-webkit-max-content;width:-moz-max-content;width:max-content;text-align:start}::ng-deep .highlight-date[data-tooltip]:hover::before{content:'';position:absolute;top:-8px;left:50%;-webkit-transform:translateX(-50%);transform:translateX(-50%);border:4px solid transparent;border-top-color:#333;z-index:1000}`],\n  providers: [\n    { provide: MAT_DATE_FORMATS, useValue: MY_FORMATS },\n    { provide: DateAdapter, useClass: MomentDateAdapter },\n    {\n      provide: NG_VALUE_ACCESSOR,\n      useExisting: forwardRef(() => NgxDateTimePickerComponent),\n      multi: true\n    }\n  ]\n})\nexport class NgxDateTimePickerComponent\n  implements OnInit, ControlValueAccessor {\n  // public date = new FormControl(moment());\n  public selectedTime = moment().format();\n  public selectedDate = moment().format();\n  public loadInitial = false;\n  public value;\n  public showTimePicker = false;\n  @Input() weeks: number[] = [0, 2, 4, 6, 8, 12, 16, 24];\n  @Input() modelValue: any;\n  @Input() showTime = false;\n  @Input() showWeeks = true;\n  @Input() dateFormat = 'MMMM DD, YYYY (dddd)';\n\n  private _showHolidays = true;\n  @Input()\n  public set showHolidays(v: boolean | string) {\n    this._showHolidays = v === true || v === 'true';\n  }\n\n  @ViewChild('picker') picker: MatDatepicker<Date>;\n\n  private observer: MutationObserver | null = null;\n\n  private _dataSource: any;\n  @Input()\n  public get dataSource(): any {\n    return this._dataSource;\n  }\n  public set dataSource(v: any) {\n    this._dataSource = v;\n  }\n\n  @Output() onDateChange = new EventEmitter<any>();\n  public onChange: any = () => {};\n  public onTouched: any = () => {};\n  public ngOnInit() {}\n\n  public writeValue(value) {\n    this.value = value;\n  }\n\n  public registerOnChange(fn) {\n    this.onChange = fn;\n  }\n\n  public registerOnTouched(fn) {}\n\n  public onTimeSelect($event) {\n    const setDate = moment(this.selectedDate);\n    const setTime = $event;\n    this.setDateTime(setDate, setTime);\n  }\n\n  public onDateSelect($event) {\n    const setDate = moment($event.value);\n    const setTime = this.selectedTime;\n    const dateString = this.setDateTime(setDate, setTime);\n\n    const selectedDate = $event.value;\n    this.value = dateString;\n  }\n\n  public toggleTimePicker(status: boolean): void {\n    this.showTimePicker = status;\n    return;\n  }\n\n  public setCurrentTime() {\n    const setDate = moment(this.selectedDate);\n    const currentTime = moment().format('HH:mm:ss');\n    this.setDateTime(setDate, currentTime);\n  }\n\n  public weekSelect($event) {\n    const dateToUse = moment().format();\n    const nextWeekDate = moment(dateToUse).add($event.value, 'weeks');\n    const nextWeekTime = dateToUse;\n    this.setDateTime(nextWeekDate, nextWeekTime);\n  }\n\n  public selectionChange($event) {\n    console.log('Week selected', $event);\n  }\n\n  public getWeekPickerCssClass() {\n    if (this.showTime) {\n      return 'col-sm-2 form-group';\n    }\n    return 'col-sm-3 form-group';\n  }\n\n  public getDatePickerCssClass() {\n    if (this.showTime && this.showWeeks) {\n      return 'col-sm-5 form-group';\n    }\n\n    if (this.showWeeks === true) {\n      return 'col-sm-9 form-group';\n    }\n\n    if (this.showTime === true) {\n      return 'col-sm-8 form-group';\n    }\n    return 'col-sm-12 form-group';\n  }\n\n  public getTimePickerCssClass() {\n    if (this.showTime && this.showWeeks) {\n      return 'col-sm-5 form-group';\n    }\n\n    if (this.showWeeks === true) {\n      return 'col-sm-9 form-group';\n    }\n    return 'col-sm-4 form-group';\n  }\n\n  public setDateTime(setDate, setTime) {\n    const newDate = moment(setDate).format('DD-MM-YYYY');\n    let newTime;\n    if (this.showTime) {\n      newTime = moment(setTime).format('HH:mm:ss');\n    } else {\n      newTime = '00:00:00';\n    }\n    const newDateTime = moment(newDate + '' + newTime, 'DD-MM-YYYY HH:mm:ss');\n    const dateTimeString = moment(newDateTime).format();\n    this.selectedDate = dateTimeString;\n    this.selectedTime = dateTimeString;\n    this.value = dateTimeString;\n    this.onChange(this.value);\n\n    return dateTimeString;\n  }\n\n  onOpen() {\n    if (this._showHolidays) {\n      const calendarBody = document.querySelector('.mat-calendar-content');\n      if (calendarBody) {\n        this.observer = new MutationObserver(() => {\n          this.highlightHolidays();\n        });\n        this.observer.observe(calendarBody, {\n          childList: true,\n          subtree: true\n        });\n      }\n    }\n  }\n\n  onClose() {\n    if (this.observer) {\n      this.observer.disconnect();\n      this.observer = null;\n    }\n  }\n\n  public highlightHolidays() {\n    const isMonthView = !!document.querySelector('mat-month-view');\n    if (!isMonthView) {\n      const calendarCells = document.querySelectorAll(\n        '.mat-calendar-body-cell'\n      );\n      for (let i = 0; i < calendarCells.length; i++) {\n        calendarCells[i].classList.remove('highlight-date');\n        calendarCells[i].removeAttribute('data-tooltip');\n      }\n      return;\n    }\n\n    const cells = document.querySelectorAll('.mat-calendar-body-cell');\n    for (let i = 0; i < cells.length; i++) {\n      const cell = cells[i];\n      const date = new Date(cell.getAttribute('aria-label'));\n      const cellDate = moment(date).format('YYYY-MM-DD');\n\n      const holidays = this.dataSource.filter((v) => v.date === cellDate);\n      if (holidays.length > 0) {\n        const holidayName = holidays\n          .map((h) => h.name)\n          .sort()\n          .join('\\n\\n');\n        cell.classList.add('highlight-date');\n        cell.setAttribute('data-tooltip', holidayName);\n      } else {\n        cell.classList.remove('highlight-date');\n        cell.removeAttribute('data-tooltip');\n      }\n    }\n  }\n}\n"]}

package/esm2015/components/ngx-date-time-picker/ngx-date-time-picker.module.js

@@ -0,0 +1,43 @@
+/**
+ * date-time-picker.module
+ */
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { FormsModule, ReactiveFormsModule } from '@angular/forms';
+import { MatDatepickerModule } from '@angular/material/datepicker';
+import { MatFormFieldModule } from '@angular/material/form-field';
+import { MatNativeDateModule, MatInputModule, MatTooltipModule } from '@angular/material';
+import { NgxDateTimePickerComponent } from './ngx-date-time-picker.component';
+// import { AmazingTimePickerModule } from 'amazing-time-picker';
+import { MatSelectModule } from '@angular/material/select';
+import { DateTimePickerModule } from '../date-time-picker/date-time-picker.module';
+export class NgxDateTimePickerModule {
+}
+NgxDateTimePickerModule.decorators = [
+    { type: NgModule, args: [{
+                imports: [
+                    CommonModule,
+                    FormsModule,
+                    ReactiveFormsModule,
+                    MatDatepickerModule,
+                    MatFormFieldModule,
+                    MatNativeDateModule,
+                    MatInputModule,
+                    DateTimePickerModule,
+                    // AmazingTimePickerModule,
+                    MatSelectModule,
+                    MatTooltipModule
+                ],
+                declarations: [NgxDateTimePickerComponent],
+                exports: [
+                    MatDatepickerModule,
+                    MatFormFieldModule,
+                    MatNativeDateModule,
+                    MatInputModule,
+                    NgxDateTimePickerComponent
+                ],
+                providers: []
+            },] },
+];
+
+//# sourceMappingURL=data:application/json;base64,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