/* searchText 제거
  public getSearchCountDataSets(datasetId: string, searchWord: string, count: number) {
    let popupService = this.popupService;
    return this.get(this.API_URL + `preparationdatasets/${datasetId}/transform?searchWord=` + encodeURIComponent(searchWord) + '&targetLines=' + count)
  */
  public getSearchCountDataSets(datasetId: string, ruleIdx?: number, pageNum?: number, count?: number) {
    let popupService = this.popupService;
    let url = this.API_URL + `preparationdatasets/${datasetId}/transform`;

    const params: string[] = [];

    if (isNullOrUndefined(ruleIdx)) {
      (params.push(`ruleIdx=`));
    } else {
      (params.push(`ruleIdx=${ruleIdx}`));
    }
    (isNullOrUndefined(pageNum)) || (params.push(`offset=${pageNum}`));
    (isNullOrUndefined(count)) || (params.push(`count=${count}`));
    (0 < params.length) && (url = url + '?' + params.join('&'));

    return this.get(url)
      .catch((error) => {
        if (true !== isUndefined(error.code) && error.code === 'PR5102') {
          Loading.hide();
          PreparationAlert.success(this.translateService.instant(error.details));
          popupService.notiPopup({ name: 'update-dataflow', data: null });
          return Promise.reject(null);
        }
        throw error;
      });
  }

 .then((res: any) => {
   return createStory(state.configuration.token, {
     name: res.title,
     description: res.description,
     owner_ids: isNullOrUndefined(res.owner) ? null : [res.owner],
     project_id: parseInt(res.project, 10),
     epic_id: res.epic,
     labels: isNullOrUndefined(res.labels) ? null : [res.labels],
     story_type: res.storyType,
   } as IStory)
     .then((story: IStory) => {
       const id = story.id;
       const storySlug = slug(story.name).toLowerCase();
       const gitCmd = `git checkout -b ${story.story_type}/ch${id}/${storySlug}`;
       console.info(Chalk.green(`Successfully created a story with id ${id}`));
       console.info("You can view your story at " + link(`https://app.clubhouse.io/story/${id}`));
       console.info("To start working on this story (copied to clipboard): " + Chalk.bold(gitCmd));
       writeSync(gitCmd);
       return story;
     })
     .catch((err: any) => {
       console.error(Chalk.red("There was an error processing your request"));
       console.error(err.body);
     });
 });

 Edges.forEach(function(Edge: edge) {
     if(!(Util.isNullOrUndefined(Edge.to) || Util.isNullOrUndefined(Edge.from) || Util.isNullOrUndefined(Edge.rule)))
     {
         Ninja.edge(Edge.to).from(Edge.from).using(Edge.rule);
     }
     else
     {
         console.log('Invalid edge ', Edge, ' requires "to", "from" and "rule"')
     }
 });

  /**
   * Validator that checks if the control value is a http url.
   *
   * @param control
   * @returns {{isUri: boolean}}
   */
  static isHttpUrl(control: AbstractControl): ValidationErrors | null {
    const value = control.value;
    let match = isNullOrUndefined(value) ? null : parseUri(value);

    return (isNullOrUndefined(match)
      || match[1].indexOf('http') !== 0 // check for protocol http(s)
      || match[2] !== '//'              // check for both // after protocol
      || match[4].trim().length === 0    // check that host is given
    ) ?
      {'isHttpUrl': true} : null;
  }

 private appendAuthenticationToken(options?: RequestOptionsArgs) {
     if (isNullOrUndefined(options)) {
         options = new RequestOptions();
     }
     if (isNullOrUndefined(options.headers)) {
         options.headers = new Headers();
     }
     options.headers.append('Accept', 'application/json');
     if (localStorage.getItem('oauth')) {
         options.withCredentials = true;
         options.headers.append('Authorization', 'Bearer ' + this.getToken());
     }
     return options;
 }

function setGoEnvironmentVariables(goRoot: string) {
    tl.setVariable('GOROOT', goRoot);

    let goPath: string = tl.getInput("goPath", false);
    let goBin: string = tl.getInput("goBin", false);

    // set GOPATH and GOBIN as user value
    if (!util.isNullOrUndefined(goPath)) {
        tl.setVariable("GOPATH", goPath);
    }
    if (!util.isNullOrUndefined(goBin)) {
        tl.setVariable("GOBIN", goBin);
    }
}

    /**
     * getLicense returns License instance with licenser.license setting.
     * @param typ License type specified in settings.json.
     */
    private getLicense(typ: string): License {
        let licenserSetting = vscode.workspace.getConfiguration("licenser");
        let projectName = licenserSetting.get<string>("projectName", undefined);
        console.log("Project Name from settings: " + projectName);
        if (projectName !== undefined && projectName === "") {
            let root = vscode.workspace.rootPath;
            projectName = path.basename(root);
        }
        console.log("Project Name used: " + projectName);
        const licenseKey = typ.toUpperCase();

        if (licenseKey === "CUSTOM") {
            let customTermsAndConditions = licenserSetting.get<string>("customTermsAndConditions");
            let customHeader = licenserSetting.get<string>("customHeader");
            let fileName = vscode.window.activeTextEditor.document.fileName;
            return new Custom(this.author, projectName, customTermsAndConditions, customHeader, fileName);
        }

        let info = availableLicenses.get(licenseKey);
        if (isNullOrUndefined(info)) {
            info = availableLicenses.get(defaultLicenseType);
        }

        return info.creatorFn(this.author, projectName);
    }

 static getValidValue<T>(field: T, value: T): T {
   if (isNullOrUndefined(field)) {
     return value;
   } else {
     return field;
   }
 }

 constructor(graph: Remath, initialState: ISymbolState) {
    super(graph, initialState);
    this._symbol = null;
    if (!initialState || isNullOrUndefined(initialState.symbol)) throw Error('must provide a symbol when creating a cell');
    this.updateSymbol(initialState.symbol);
    this._tempInvalidSymbol = null;
 }

 return metadataArray.map(item => {
   if (isNullOrUndefined(entity)) {
     return new FormMetadata(item);
   } else {
     return new FormMetadata(item, entity);
   }
 });

 constructor(public metadata: DomainMetadata,
             value?: any | ValueObject) {
   // if (value && value[metadata.key]) {
   //   this.defValue = value[metadata.key];
   // }
   if (!isNullOrUndefined(value)) {
     if (value instanceof ValueObject) {
       if (!isNullOrUndefined(value.value)) {
         this.defValue = value.value[metadata.key];
       }
       this.list = value.list;
     } else {
       this.defValue = value[metadata.key];
     }
   }
 }

  } // function - transformAction


  // Wrangled 데이터셋 조회 (조인과 유니온에서 사용)
  public getDatasetWrangledData(datasetId: string, count?: number, pageNum?: number, ruleIdx?: number): Promise<any> {

    // TODO : temp value
    count = 1000;
    pageNum = 0;

    let url = this.API_URL + `preparationdatasets/${datasetId}/transform`;

    const params: string[] = [];
    (params.push(`ruleIdx=`));
    (isNullOrUndefined(pageNum)) || (params.push(`offset=${pageNum}`));
    (isNullOrUndefined(count)) || (params.push(`count=${count}`));
    (0 < params.length) && (url = url + '?' + params.join('&'));

    return this.get(url);
  }

  private async buildAndInsertMediumByFilePathAsync(
    mediumFilePath: string,
    index: number
  ): Promise<IMediumModel> {
    const normalizedMediumFilePath = this.fileExplorerService.normalizePathForCurrentOs(mediumFilePath);

    let model = await MediumModel.buildFromFilePathAsync(
      this.mediaService,
      this.mediaRepository,
      () => this.index,
      normalizedMediumFilePath
    );
    const medium = await this.mediaRepository.addMediumAsync(model.toEntity());
    model.setFromEntity(medium);

    if (isNullOrUndefined(index)) { // We'll append medium
      const media = await this.media.valueAsync;
      media.push(model);
    } else {
      const media = await this.media.valueAsync;
      media.splice(index, 0, model);
    }

    return model;
  }

 init() {
   this.activePage = null;
   this.docked = false;
   this.state = 'collapsed';
   if (isNullOrUndefined(this.height)) {
     this.height = 60;
   }
 }

function getAutoCompleteChoices(input: string, data: ChoiceOption[]) {
  if (isNullOrUndefined(input)) {
    return Promise.resolve(data);
  } else {
    const filtered = data
      .filter((item: ChoiceOption) => item.name.toLowerCase().includes(input.toLowerCase()));
    return Promise.resolve(filtered);
  }
}

export function createStory(token: string, story: IStory): Promise<IStory> {
  const client = require('clubhouse-lib').create(token);
  const reqObj = pick(story, ['name', 'description', 'story_type', 'epic_id', 'project_id', 'labels']) as any;

  if (!isNullOrUndefined(story.owner_ids)) {
    reqObj.owner_ids = Array.isArray(story.owner_ids) ? story.owner_ids : [story.owner_ids];
  }
  return client.createStory(reqObj);
}

    canActivate() {
        let sessionToken = this.cookieService.get('sessionToken');

        if (isNullOrUndefined(sessionToken)) {
            this.stateService.setLoggedOut();
            // noinspection JSIgnoredPromiseFromCall
            this.router.navigateByUrl('not-logged-in');
        }
        return sessionToken != null;
    }

        operation.steps.forEach((step: OperationStep) => {
            const newStep = {
                ...step
            };
            if (!isNullOrUndefined(newStep.move)) {
                newStep.move -= totalMoves;
            }

            this.steps.push(newStep);
        });

 activateItem(item: MenuItemComponent) {
   if (isNullOrUndefined(this.activeItem)) {
     this.activeItem = item;
     this.activeItem.activate();
   } else {
     this.activeItem.deactivate();
     this.activeItem = item;
     this.activeItem.activate();
   }
 }

    private _chooseLicenseType(): Thenable<string> {
        let licenserSetting = vscode.workspace.getConfiguration("licenser");
        let licenseType = licenserSetting.get<string>("license");

        if (isNullOrUndefined(licenseType) || licenseType.toLowerCase() == chooseFromList) {
            return vscode.window.showQuickPick(Array.from(availableLicenses.values()).map(info => info.displayName));
        }

        return new Promise((resolve, _) => resolve(licenseType));
    }