src/app/projects/project-create-update/ProjectCreateUpdateComponent.ts

   1 /*
   2  Copyright 2020 TATA ELXSI
   3
   4  Licensed under the Apache License, Version 2.0 (the 'License');
   5  you may not use this file except in compliance with the License.
   6  You may obtain a copy of the License at
   7
   8   http://www.apache.org/licenses/LICENSE-2.0
   9
  10  Unless required by applicable law or agreed to in writing, software
  11  distributed under the License is distributed on an "AS IS" BASIS,
  12  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  See the License for the specific language governing permissions and
  14  limitations under the License.
  15
  16  Author: KUMARAN M (kumaran.m@tataelxsi.co.in), RAJESH S (rajesh.s@tataelxsi.co.in), BARATH KUMAR R (barath.r@tataelxsi.co.in)
  17 */
  18 /**
  19  * @file Project Add Modal
  20  */
  21 import { Component, Injector, Input, OnInit } from '@angular/core';
  22 import { AbstractControl, FormBuilder, FormControl, FormGroup, Validators } from '@angular/forms';
  23 import { NgbActiveModal } from '@ng-bootstrap/ng-bootstrap';
  24 import { TranslateService } from '@ngx-translate/core';
  25 import { NotifierService } from 'angular-notifier';
  26 import { APIURLHEADER, ERRORDATA, MODALCLOSERESPONSEDATA } from 'CommonModel';
  27 import { DataService } from 'DataService';
  28 import { environment } from 'environment';
  29 import { ProjectData, ProjectDetails, QUOTA_ITEMS, QUOTAITEM} from 'ProjectModel';
  30 import { ProjectService } from 'ProjectService';
  31 import { RestService } from 'RestService';
  32 import { SharedService } from 'SharedService';
  33 import { isNullOrUndefined } from 'util';
  34
  35 /**
  36  * Creating component
  37  * @Component takes ProjectCreateUpdateComponent.html as template url
  38  */
  39 @Component({
  40   selector: 'app-project-create-update',
  41   templateUrl: './ProjectCreateUpdateComponent.html',
  42   styleUrls: ['./ProjectCreateUpdateComponent.scss']
  43 })
  44 /** Exporting a class @exports ProjectCreateUpdateComponent */
  45 export class ProjectCreateUpdateComponent implements OnInit {
  46   /** To inject services @public */
  47   public injector: Injector;
  48
  49   /** Instance of the rest service @public */
  50   public restService: RestService;
  51
  52   /** Instance for active modal service @public */
  53   public activeModal: NgbActiveModal;
  54
  55   /** Contains the recently created project details @public */
  56   public recentProject: ProjectDetails;
  57
  58   /** Contains project create or edit @public */
  59   public getProjectType: string;
  60
  61   /** To inject input type services @public */
  62   @Input() public projectType: string;
  63
  64   /** FormGroup user Edit Account added to the form @ html @public */
  65   public projectForm: FormGroup;
  66
  67   /** Form submission Add */
  68   public submitted: boolean = false;
  69
  70   /** Check the loading results for loader status @public */
  71   public isLoadingResults: boolean = false;
  72
  73   /** Give the message for the loading @public */
  74   public message: string = 'PLEASEWAIT';
  75
  76   /** Holds list of domains @public */
  77   public domains: {}[] = [];
  78
  79   /** Holds list of quota items @public */
  80   public quotaItems: QUOTAITEM[] = QUOTA_ITEMS;
  81
  82   /** Holds project reference from response  @public */
  83   public quotaRefs: {} = null;
  84
  85   /** FormBuilder instance added to the formBuilder @private */
  86   private formBuilder: FormBuilder;
  87
  88   /** DataService to pass the data from one component to another @private */
  89   private dataService: DataService;
  90
  91   /** Contains project name ref @private */
  92   private projectRef: string;
  93
  94   /** Notifier service to popup notification @private */
  95   private notifierService: NotifierService;
  96
  97   /** Contains tranlsate instance @private */
  98   private translateService: TranslateService;
  99
 100   /** Contains all methods related to shared @private */
 101   private sharedService: SharedService;
 102
 103   /** ModalData instance of modal @private  */
 104   private modalData: MODALCLOSERESPONSEDATA;
 105
 106   /** Holds all project details @private */
 107   private projectService: ProjectService;
 108
 109   constructor(injector: Injector) {
 110     this.injector = injector;
 111     this.formBuilder = this.injector.get(FormBuilder);
 112     this.restService = this.injector.get(RestService);
 113     this.activeModal = this.injector.get(NgbActiveModal);
 114     this.dataService = this.injector.get(DataService);
 115     this.notifierService = this.injector.get(NotifierService);
 116     this.translateService = this.injector.get(TranslateService);
 117     this.sharedService = this.injector.get(SharedService);
 118     this.projectService = this.injector.get(ProjectService);
 119     /** Initializing Form Action */
 120     this.projectForm = this.formBuilder.group({
 121       project_name: ['', Validators.required],
 122       domain_name: [null],
 123       enable_quota: [false, Validators.required]
 124     });
 125   }
 126
 127   /** convenience getter for easy access to form fields */
 128   get f(): FormGroup['controls'] { return this.projectForm.controls; }
 129
 130   /** Lifecyle Hooks the trigger before component is instantiate @public */
 131   public ngOnInit(): void {
 132     this.getProjectType = this.projectType;
 133     if (this.getProjectType === 'Edit') {
 134       this.dataService.currentMessage.subscribe((data: ProjectData) => {
 135         if (data.projectName !== undefined || data.projectName !== '' || data.projectName !== null) {
 136           this.projectForm.patchValue({ project_name: data.projectName });
 137           this.projectRef = data.id;
 138           this.quotaRefs = data.quotas;
 139           this.patchQuotaInfo(this.quotaRefs);
 140         }
 141       });
 142     } else {
 143       this.patchQuotaInfo();
 144       this.getProjects();
 145     }
 146   }
 147
 148   /** Get the last project name @public */
 149   public getProjects(): void {
 150     this.isLoadingResults = true;
 151     this.restService.getResource(environment.PROJECTS_URL).subscribe((projects: ProjectDetails[]) => {
 152       this.recentProject = projects.slice(-1).pop();
 153       this.getDomainName();
 154     }, (error: ERRORDATA) => {
 155       this.restService.handleError(error, 'get');
 156       this.isLoadingResults = false;
 157     });
 158   }
 159
 160   /** On modal submit users acction will called @public */
 161   public projectAction(userType: string): void {
 162     this.submitted = true;
 163     this.modalData = {
 164       message: 'Done'
 165     };
 166     this.sharedService.cleanForm(this.projectForm);
 167     if (!this.projectForm.invalid) {
 168       if (userType === 'Add') {
 169         this.createProject();
 170       } else if (userType === 'Edit') {
 171         this.editProject();
 172       }
 173     }
 174   }
 175
 176   /** Create project @public */
 177   public createProject(): void {
 178     this.isLoadingResults = true;
 179     const apiURLHeader: APIURLHEADER = {
 180       url: environment.PROJECTS_URL
 181     };
 182     const projectPayload: ProjectDetails = {
 183       name: this.projectForm.value.project_name,
 184       domain_name: !isNullOrUndefined(this.projectForm.value.domain_name) ? this.projectForm.value.domain_name : undefined
 185     };
 186     this.addQuotaLimit(projectPayload);
 187     this.restService.postResource(apiURLHeader, projectPayload).subscribe(() => {
 188       this.activeModal.close(this.modalData);
 189       this.isLoadingResults = false;
 190       this.notifierService.notify('success', this.translateService.instant('PAGE.PROJECT.CREATEDSUCCESSFULLY'));
 191     }, (error: ERRORDATA) => {
 192       this.restService.handleError(error, 'post');
 193       this.isLoadingResults = false;
 194     });
 195   }
 196   /** Handle enable quota limit checkbox event @public */
 197   public checkQuota(): void {
 198     if (this.getFormControl('enable_quota').value) {
 199       this.quotaItems.forEach((quotaItem: QUOTAITEM): void => {
 200         this.projectForm.addControl(quotaItem.value, new FormControl(quotaItem.minValue, Validators.required));
 201       });
 202     } else {
 203       this.quotaItems.forEach((quotaItem: QUOTAITEM): void => {
 204         this.getFormControl(quotaItem.value).setValue(quotaItem.minValue);
 205       });
 206     }
 207   }
 208   /** Edit project @public */
 209   public editProject(): void {
 210     this.isLoadingResults = true;
 211     const apiURLHeader: APIURLHEADER = {
 212       url: environment.PROJECTS_URL + '/' + this.projectRef
 213     };
 214     const projectPayload: ProjectDetails = {
 215       name: this.projectForm.value.project_name
 216     };
 217     this.addQuotaLimit(projectPayload);
 218     this.restService.patchResource(apiURLHeader, projectPayload).subscribe(() => {
 219       this.activeModal.close(this.modalData);
 220       this.isLoadingResults = false;
 221       this.projectService.setHeaderProjects();
 222       this.notifierService.notify('success', this.translateService.instant('PAGE.PROJECT.UPDATEDSUCCESSFULLY'));
 223     }, (error: ERRORDATA) => {
 224       this.restService.handleError(error, 'patch');
 225       this.isLoadingResults = false;
 226     });
 227   }
 228   /** Get domain name @private */
 229   private getDomainName(): void {
 230     this.restService.getResource(environment.DOMAIN_URL).subscribe((domains: { project_domain_name: string, user_domain_name: string }) => {
 231       let domainNames: string[] = [];
 232       if (!isNullOrUndefined(domains.project_domain_name)) {
 233         domainNames = domainNames.concat(domains.project_domain_name.split(','));
 234       }
 235       if (!isNullOrUndefined(domains.user_domain_name)) {
 236         domainNames = domainNames.concat(domains.user_domain_name.split(','));
 237       }
 238       domainNames = Array.from(new Set(domainNames));
 239       this.checkDomainNames(domainNames);
 240       this.isLoadingResults = false;
 241     }, (error: ERRORDATA) => {
 242       this.restService.handleError(error, 'get');
 243       this.isLoadingResults = false;
 244     });
 245   }
 246
 247   /** Check the domain names and create modal for domain select @private */
 248   private checkDomainNames(domainNames: string[]): void {
 249     if (domainNames.length > 0) {
 250       domainNames.forEach((domainName: string) => {
 251         if (!domainName.endsWith(':ro')) {
 252           this.domains.push({ id: domainName, text: domainName });
 253         }
 254       });
 255     }
 256   }
 257
 258   /** Used to get the AbstractControl of controlName passed @private */
 259   private getFormControl(controlName: string): AbstractControl {
 260     return this.projectForm.controls[controlName];
 261   }
 262
 263   /** Add quota information to payload @private */
 264   private addQuotaLimit(payload: ProjectDetails): void {
 265     if (this.getFormControl('enable_quota').value) {
 266       payload.quotas = {};
 267       this.quotaItems.forEach((quotaItem: QUOTAITEM): void => {
 268         payload.quotas[quotaItem.value] = this.getFormControl(quotaItem.value).value;
 269       });
 270     }
 271   }
 272
 273   /** Set quota information in project form model @private */
 274   private patchQuotaInfo(quotaRef?: {}): void {
 275     if (quotaRef !== null && this.getProjectType === 'Edit') {
 276       this.getFormControl('enable_quota').setValue(true);
 277       this.quotaItems.forEach((quotaItem: QUOTAITEM): void => {
 278         if (!isNullOrUndefined(quotaRef[quotaItem.value])) {
 279           this.projectForm.addControl(quotaItem.value, new FormControl(quotaRef[quotaItem.value],
 280             [Validators.required, Validators.min(quotaItem.minValue), Validators.max(quotaItem.maxValue)]));
 281         } else {
 282           this.projectForm.addControl(quotaItem.value, new FormControl(quotaItem.minValue, [Validators.required,
 283           Validators.min(quotaItem.minValue), Validators.max(quotaItem.maxValue)]));
 284         }
 285       });
 286     } else {
 287       this.quotaItems.forEach((quotaItem: QUOTAITEM): void => {
 288         this.projectForm.addControl(quotaItem.value, new FormControl(quotaItem.minValue, [Validators.required,
 289         Validators.min(quotaItem.minValue), Validators.max(quotaItem.maxValue)]));
 290       });
 291     }
 292   }
 293 }