### File

`src/app/core/services/variant-parser.service.ts`

### Constructor

`constructor()`
Defined in src/app/core/services/variant-parser.service.ts:20

### Methods

getOptionsToDisplay
`getOptionsToDisplay(variants: Variant[], optionTypes: OptionType[])`
Defined in src/app/core/services/variant-parser.service.ts:32
Parameters : variants optionTypes Returns: `void` *

singleOptionTypeHashMaker
`singleOptionTypeHashMaker(optionValue: OptionValue, optionTypesHash: OptionTypesHash, optionType: OptionType, variant: Variant)`
Defined in src/app/core/services/variant-parser.service.ts:66
Create a single custom option type: optionValue, optionTypesHash(final hash to return), optionType(i.e tsize, tcolor, etc), variant(i.e current variant from which option value is to retrived e.g: (s-small, green)) Returns: `void`

optionMaker
`optionMaker(optionValue: OptionValue, optionTypesHash: OptionTypesHash, optionType: OptionType, variant: Variant)`
Defined in src/app/core/services/variant-parser.service.ts:91
Here we make optionvalue of option Type say optionType is tsize i.e key then here we making value of that option OptionType like { small: {optionvalue: {}, variant_ids: [1,2,3,4]}}; Returns: `void`

optionInnerValueMaker
`optionInnerValueMaker(optionValue: OptionValue, optionTypesHash: OptionTypesHash, optionType: OptionType, variant: Variant)`
Defined in src/app/core/services/variant-parser.service.ts:105
Creates Inner Values of optionValue like { option_value: {}, varaint_ids: [1,2,3,4]}; Returns: `void`

variantIdsMaker
`variantIdsMaker(optionValue: OptionValue, optionTypesHash: OptionTypesHash, optionType: OptionType, variant: Variant)`
Defined in src/app/core/services/variant-parser.service.ts:120
Checks if the optionType and the optionvalue of that type exist in OptionTypesHash i.e "tsize" exists in the main hash that we are creating and corresponding "small" value exists too then take arr of the variant ids and push a new id in it and return; else create a new array of the varaint id and return; Returns: `void`

getOtherOptionValues
`getOtherOptionValues(optionValue: any, currOptionType: any)`
Defined in src/app/core/services/variant-parser.service.ts:141
Parameters : optionValue currOptionType Returns: `void` *

### Properties

currVariantOptionValues
`currVariantOptionValues: `any``
Defined in src/app/core/services/variant-parser.service.ts:20

    import { Effect } from '@ngrx/effects';
    import { OptionValue } from './../models/option_value';
    import { element } from 'protractor';
    import { Variant } from './../models/variant';
    import { OptionType } from './../models/option_type';
    import { Injectable } from '@angular/core';

    /**Custom Interface for return option hash */
    interface OptionTypesHash {
      [id: string]: {
        [id: string]: {
          optionValue: {},
          variantIds: Array<any>;
        }
      };
    }

    @Injectable()
    export class VariantParserService {
      currVariantOptionValues: any;
      constructor() { }

      /**
       *
       *
       * @param {Variant[]} variants
       * @param {OptionType[]} optionTypes
       * @returns
       *
       * @memberof VariantParserService
       */
      getOptionsToDisplay(variants: Variant[], optionTypes: OptionType[]) {
        const optionTypesHash: OptionTypesHash = {};

        /**Iterate over optionTypes say [tsize, tcolor] */
        optionTypes.forEach(optionType => {
          /**For each optionType iterate over each variant in varaints */
          variants.forEach(variant => {
            /**For option values like [small, Red] etc in varaint iterate over each option value */
            this.currVariantOptionValues = variant.option_values;
            variant.option_values.forEach(optionValue => {
              /**
              * This loop runs for 750 times for 2 optiontypes and optionsvalues 3 and 5
              * Refactor this latter;
              */

              /**Check if optionvalue's type i.e smalls type is tsize and then procced else not
               * i.e for tsize option type color option value like green will be ignored.
               */
              if (optionValue.option_type_name === optionType.name) {
                Object.assign(optionTypesHash, this.singleOptionTypeHashMaker(optionValue, optionTypesHash, optionType, variant));
              }
            });
          });
        });
        return optionTypesHash;
      }

      /**Create a single custom option type
       *
       * @param: optionValue, optionTypesHash(final hash to return), optionType(i.e tsize, tcolor, etc),
       * variant(i.e current variant from which option value is to retrived e.g: (s-small, green))
       *
       * @return: {tsize: {small: {etc etc etc}}};
       */
      singleOptionTypeHashMaker(optionValue: OptionValue, optionTypesHash: OptionTypesHash,
        optionType: OptionType, variant: Variant) {

        const optionTypeName: string = optionType.name;
        if (optionTypesHash[optionTypeName] != null) {

          // This will become value of op["tsize"] i.e {small: {etc, etc}};
          optionTypesHash[optionTypeName] = Object.assign({},
            optionTypesHash[optionTypeName],
            this.optionMaker(optionValue, optionTypesHash, optionType, variant));

          return optionTypesHash;
        } else {
          const singleOption = {};
          // e.g: singleOption["tsize"] = {small: {etc, etc}};
          singleOption[optionTypeName] = this.optionMaker(optionValue, optionTypesHash, optionType, variant);
          return singleOption;
        }
      }

      /**
       * Here we make optionvalue of option Type
       * say optionType is tsize  i.e key then here we making value of that option OptionType
       * like { small: {optionvalue: {}, variant_ids: [1,2,3,4]}};
       */
      optionMaker(optionValue: OptionValue, optionTypesHash: OptionTypesHash,
        optionType: OptionType, variant: Variant) {

        const name = optionValue.name;
        const optionInnerValue = {};
        // e.g: optionInnverValue['small'] = {option_value: {etc ,etc}, variant_ids: [1,2,3,4]}
        optionInnerValue[name] = this.optionInnerValueMaker(optionValue, optionTypesHash, optionType, variant);
        return optionInnerValue;
      }

      /**
       * Creates Inner Values of optionValue
       * like { option_value: {}, varaint_ids: [1,2,3,4]};
       */
      optionInnerValueMaker(optionValue: OptionValue, optionTypesHash: OptionTypesHash,
        optionType: OptionType, variant: Variant) {

        return Object.assign({}, {
          optionValue: optionValue,
          variantIds: this.variantIdsMaker(optionValue, optionTypesHash, optionType, variant)
        });
      }

      /**
       * Checks if the optionType  and the optionvalue of that type exist in OptionTypesHash
       * i.e "tsize" exists in the main hash that we are creating and corresponding "small" value exists too
       * then take arr of the variant ids and push a new id in it and return;
       * else create a new array of the varaint id and return;
       */
      variantIdsMaker(optionValue: OptionValue, optionTypesHash: OptionTypesHash,
        optionType: OptionType, variant: Variant) {
        const currespondingOptionValues = this.getOtherOptionValues(optionValue, optionType);
        if (optionTypesHash[optionType.name] != null && optionTypesHash[optionType.name][optionValue.name] != null) {
          const variantArr = optionTypesHash[optionType.name][optionValue.name].variantIds;
          variantArr.push({[variant.id]: currespondingOptionValues });
          return variantArr;
        } else {
          return Array.of({[variant.id]: currespondingOptionValues});
        }
      }

      /**
       *
       *
       * @param {any} optionValue
       * @param {any} currOptionType
       * @returns
       *
       * @memberof VariantParserService
       */
      getOtherOptionValues(optionValue, currOptionType) {
        const correspondingOptionValues: any = [];
        for (let i = 0; i < this.currVariantOptionValues.length; i++) {
          if (this.currVariantOptionValues[i].option_type_name !== currOptionType.name) {
            correspondingOptionValues.push({ [this.currVariantOptionValues[i].option_type_name]: this.currVariantOptionValues[i].name });
          }
        }
        return correspondingOptionValues;
      }
    }

# results matching ""

# No results matching ""