Пример #1
0
  /**
   * convert Map to ContactObjectFilter.
   *
   * @param record the Map containing the data to convert to the object, not including the root
   * @return ContactObjectFilter the converted object
   */
  public static ContactObjectFilter getFilter(Map record) {
    Object[] list = null;
    Object obj = null;
    if (record == null) return null;
    ContactObjectFilter out = new ContactObjectFilter();
    Boolean Fetch = DataHelper.getFetch(record);
    if (Fetch != null) out.setFetch(Fetch);
    Integer Index = DataHelper.getIndex(record);
    if (Index != null) out.setIndex(Index);

    out.Key = ContactObjectKeyHelper.getFilter((Map) record.get("Key"));
    Map CreateDtMap = (Map) record.get("CreateDt");
    Boolean CreateDtFetch = DataHelper.getFetch(CreateDtMap);
    Boolean CreateDtSortDir = DataHelper.getSortDirection(CreateDtMap);
    Integer CreateDtSortOrder = DataHelper.getSortOrder(CreateDtMap);
    if (CreateDtFetch != null) out.setCreateDtFetch(CreateDtFetch);
    if (CreateDtSortDir != null) out.setCreateDtSortDirection(CreateDtSortDir);
    if (CreateDtSortOrder != null) out.setCreateDtSortOrder(CreateDtSortOrder);

    Filter[] CreateDtFilter = DataHelper.mapToFilterArray(CreateDtMap, Date.class);
    if (CreateDtFilter != null) {
      DateFilter[] CreateDtFilters = new DateFilter[CreateDtFilter.length];
      for (int i = 0; i < CreateDtFilters.length; i++) {
        CreateDtFilters[i] = (DateFilter) CreateDtFilter[i];
      }
      try {
        out.setCreateDtFilter(CreateDtFilters);
      } catch (Exception x) {
        x.printStackTrace();
      }
    }

    Map ChgDtMap = (Map) record.get("ChgDt");
    Boolean ChgDtFetch = DataHelper.getFetch(ChgDtMap);
    Boolean ChgDtSortDir = DataHelper.getSortDirection(ChgDtMap);
    Integer ChgDtSortOrder = DataHelper.getSortOrder(ChgDtMap);
    if (ChgDtFetch != null) out.setChgDtFetch(ChgDtFetch);
    if (ChgDtSortDir != null) out.setChgDtSortDirection(ChgDtSortDir);
    if (ChgDtSortOrder != null) out.setChgDtSortOrder(ChgDtSortOrder);

    Filter[] ChgDtFilter = DataHelper.mapToFilterArray(ChgDtMap, Date.class);
    if (ChgDtFilter != null) {
      DateFilter[] ChgDtFilters = new DateFilter[ChgDtFilter.length];
      for (int i = 0; i < ChgDtFilters.length; i++) {
        ChgDtFilters[i] = (DateFilter) ChgDtFilter[i];
      }
      try {
        out.setChgDtFilter(ChgDtFilters);
      } catch (Exception x) {
        x.printStackTrace();
      }
    }

    Map ChgWhoMap = (Map) record.get("ChgWho");
    Boolean ChgWhoFetch = DataHelper.getFetch(ChgWhoMap);
    Boolean ChgWhoSortDir = DataHelper.getSortDirection(ChgWhoMap);
    Integer ChgWhoSortOrder = DataHelper.getSortOrder(ChgWhoMap);
    if (ChgWhoFetch != null) out.setChgWhoFetch(ChgWhoFetch);
    if (ChgWhoSortDir != null) out.setChgWhoSortDirection(ChgWhoSortDir);
    if (ChgWhoSortOrder != null) out.setChgWhoSortOrder(ChgWhoSortOrder);

    Filter[] ChgWhoFilter = DataHelper.mapToFilterArray(ChgWhoMap, String.class);
    if (ChgWhoFilter != null) {
      StringFilter[] ChgWhoFilters = new StringFilter[ChgWhoFilter.length];
      for (int i = 0; i < ChgWhoFilters.length; i++) {
        ChgWhoFilters[i] = (StringFilter) ChgWhoFilter[i];
      }
      try {
        out.setChgWhoFilter(ChgWhoFilters);
      } catch (Exception x) {
        x.printStackTrace();
      }
    }

    Map NamePrefixMap = (Map) record.get("NamePrefix");
    Boolean NamePrefixFetch = DataHelper.getFetch(NamePrefixMap);
    Boolean NamePrefixSortDir = DataHelper.getSortDirection(NamePrefixMap);
    Integer NamePrefixSortOrder = DataHelper.getSortOrder(NamePrefixMap);
    if (NamePrefixFetch != null) out.setNamePrefixFetch(NamePrefixFetch);
    if (NamePrefixSortDir != null) out.setNamePrefixSortDirection(NamePrefixSortDir);
    if (NamePrefixSortOrder != null) out.setNamePrefixSortOrder(NamePrefixSortOrder);

    Filter[] NamePrefixFilter = DataHelper.mapToFilterArray(NamePrefixMap, String.class);
    if (NamePrefixFilter != null) {
      StringFilter[] NamePrefixFilters = new StringFilter[NamePrefixFilter.length];
      for (int i = 0; i < NamePrefixFilters.length; i++) {
        NamePrefixFilters[i] = (StringFilter) NamePrefixFilter[i];
      }
      try {
        out.setNamePrefixFilter(NamePrefixFilters);
      } catch (Exception x) {
        x.printStackTrace();
      }
    }

    Map FirstNameMap = (Map) record.get("FirstName");
    Boolean FirstNameFetch = DataHelper.getFetch(FirstNameMap);
    Boolean FirstNameSortDir = DataHelper.getSortDirection(FirstNameMap);
    Integer FirstNameSortOrder = DataHelper.getSortOrder(FirstNameMap);
    if (FirstNameFetch != null) out.setFirstNameFetch(FirstNameFetch);
    if (FirstNameSortDir != null) out.setFirstNameSortDirection(FirstNameSortDir);
    if (FirstNameSortOrder != null) out.setFirstNameSortOrder(FirstNameSortOrder);

    Filter[] FirstNameFilter = DataHelper.mapToFilterArray(FirstNameMap, String.class);
    if (FirstNameFilter != null) {
      StringFilter[] FirstNameFilters = new StringFilter[FirstNameFilter.length];
      for (int i = 0; i < FirstNameFilters.length; i++) {
        FirstNameFilters[i] = (StringFilter) FirstNameFilter[i];
      }
      try {
        out.setFirstNameFilter(FirstNameFilters);
      } catch (Exception x) {
        x.printStackTrace();
      }
    }

    Map MiddleNameMap = (Map) record.get("MiddleName");
    Boolean MiddleNameFetch = DataHelper.getFetch(MiddleNameMap);
    Boolean MiddleNameSortDir = DataHelper.getSortDirection(MiddleNameMap);
    Integer MiddleNameSortOrder = DataHelper.getSortOrder(MiddleNameMap);
    if (MiddleNameFetch != null) out.setMiddleNameFetch(MiddleNameFetch);
    if (MiddleNameSortDir != null) out.setMiddleNameSortDirection(MiddleNameSortDir);
    if (MiddleNameSortOrder != null) out.setMiddleNameSortOrder(MiddleNameSortOrder);

    Filter[] MiddleNameFilter = DataHelper.mapToFilterArray(MiddleNameMap, String.class);
    if (MiddleNameFilter != null) {
      StringFilter[] MiddleNameFilters = new StringFilter[MiddleNameFilter.length];
      for (int i = 0; i < MiddleNameFilters.length; i++) {
        MiddleNameFilters[i] = (StringFilter) MiddleNameFilter[i];
      }
      try {
        out.setMiddleNameFilter(MiddleNameFilters);
      } catch (Exception x) {
        x.printStackTrace();
      }
    }

    Map LastNameMap = (Map) record.get("LastName");
    Boolean LastNameFetch = DataHelper.getFetch(LastNameMap);
    Boolean LastNameSortDir = DataHelper.getSortDirection(LastNameMap);
    Integer LastNameSortOrder = DataHelper.getSortOrder(LastNameMap);
    if (LastNameFetch != null) out.setLastNameFetch(LastNameFetch);
    if (LastNameSortDir != null) out.setLastNameSortDirection(LastNameSortDir);
    if (LastNameSortOrder != null) out.setLastNameSortOrder(LastNameSortOrder);

    Filter[] LastNameFilter = DataHelper.mapToFilterArray(LastNameMap, String.class);
    if (LastNameFilter != null) {
      StringFilter[] LastNameFilters = new StringFilter[LastNameFilter.length];
      for (int i = 0; i < LastNameFilters.length; i++) {
        LastNameFilters[i] = (StringFilter) LastNameFilter[i];
      }
      try {
        out.setLastNameFilter(LastNameFilters);
      } catch (Exception x) {
        x.printStackTrace();
      }
    }

    Map GenerationMap = (Map) record.get("Generation");
    Boolean GenerationFetch = DataHelper.getFetch(GenerationMap);
    Boolean GenerationSortDir = DataHelper.getSortDirection(GenerationMap);
    Integer GenerationSortOrder = DataHelper.getSortOrder(GenerationMap);
    if (GenerationFetch != null) out.setGenerationFetch(GenerationFetch);
    if (GenerationSortDir != null) out.setGenerationSortDirection(GenerationSortDir);
    if (GenerationSortOrder != null) out.setGenerationSortOrder(GenerationSortOrder);

    Filter[] GenerationFilter = DataHelper.mapToFilterArray(GenerationMap, String.class);
    if (GenerationFilter != null) {
      StringFilter[] GenerationFilters = new StringFilter[GenerationFilter.length];
      for (int i = 0; i < GenerationFilters.length; i++) {
        GenerationFilters[i] = (StringFilter) GenerationFilter[i];
      }
      try {
        out.setGenerationFilter(GenerationFilters);
      } catch (Exception x) {
        x.printStackTrace();
      }
    }

    Map TitleMap = (Map) record.get("Title");
    Boolean TitleFetch = DataHelper.getFetch(TitleMap);
    Boolean TitleSortDir = DataHelper.getSortDirection(TitleMap);
    Integer TitleSortOrder = DataHelper.getSortOrder(TitleMap);
    if (TitleFetch != null) out.setTitleFetch(TitleFetch);
    if (TitleSortDir != null) out.setTitleSortDirection(TitleSortDir);
    if (TitleSortOrder != null) out.setTitleSortOrder(TitleSortOrder);

    Filter[] TitleFilter = DataHelper.mapToFilterArray(TitleMap, String.class);
    if (TitleFilter != null) {
      StringFilter[] TitleFilters = new StringFilter[TitleFilter.length];
      for (int i = 0; i < TitleFilters.length; i++) {
        TitleFilters[i] = (StringFilter) TitleFilter[i];
      }
      try {
        out.setTitleFilter(TitleFilters);
      } catch (Exception x) {
        x.printStackTrace();
      }
    }

    Map CompanyMap = (Map) record.get("Company");
    Boolean CompanyFetch = DataHelper.getFetch(CompanyMap);
    Boolean CompanySortDir = DataHelper.getSortDirection(CompanyMap);
    Integer CompanySortOrder = DataHelper.getSortOrder(CompanyMap);
    if (CompanyFetch != null) out.setCompanyFetch(CompanyFetch);
    if (CompanySortDir != null) out.setCompanySortDirection(CompanySortDir);
    if (CompanySortOrder != null) out.setCompanySortOrder(CompanySortOrder);

    Filter[] CompanyFilter = DataHelper.mapToFilterArray(CompanyMap, String.class);
    if (CompanyFilter != null) {
      StringFilter[] CompanyFilters = new StringFilter[CompanyFilter.length];
      for (int i = 0; i < CompanyFilters.length; i++) {
        CompanyFilters[i] = (StringFilter) CompanyFilter[i];
      }
      try {
        out.setCompanyFilter(CompanyFilters);
      } catch (Exception x) {
        x.printStackTrace();
      }
    }

    Map AddressIdMap = (Map) record.get("AddressId");
    Boolean AddressIdFetch = DataHelper.getFetch(AddressIdMap);
    Boolean AddressIdSortDir = DataHelper.getSortDirection(AddressIdMap);
    Integer AddressIdSortOrder = DataHelper.getSortOrder(AddressIdMap);
    if (AddressIdFetch != null) out.setAddressIdFetch(AddressIdFetch);
    if (AddressIdSortDir != null) out.setAddressIdSortDirection(AddressIdSortDir);
    if (AddressIdSortOrder != null) out.setAddressIdSortOrder(AddressIdSortOrder);

    Filter[] AddressIdFilter = DataHelper.mapToFilterArray(AddressIdMap, BigInteger.class);
    if (AddressIdFilter != null) {
      BigIntegerFilter[] AddressIdFilters = new BigIntegerFilter[AddressIdFilter.length];
      for (int i = 0; i < AddressIdFilters.length; i++) {
        AddressIdFilters[i] = (BigIntegerFilter) AddressIdFilter[i];
      }
      try {
        out.setAddressIdFilter(AddressIdFilters);
      } catch (Exception x) {
        x.printStackTrace();
      }
    }

    Map AltLnameMap = (Map) record.get("AltLname");
    Boolean AltLnameFetch = DataHelper.getFetch(AltLnameMap);
    Boolean AltLnameSortDir = DataHelper.getSortDirection(AltLnameMap);
    Integer AltLnameSortOrder = DataHelper.getSortOrder(AltLnameMap);
    if (AltLnameFetch != null) out.setAltLnameFetch(AltLnameFetch);
    if (AltLnameSortDir != null) out.setAltLnameSortDirection(AltLnameSortDir);
    if (AltLnameSortOrder != null) out.setAltLnameSortOrder(AltLnameSortOrder);

    Filter[] AltLnameFilter = DataHelper.mapToFilterArray(AltLnameMap, String.class);
    if (AltLnameFilter != null) {
      StringFilter[] AltLnameFilters = new StringFilter[AltLnameFilter.length];
      for (int i = 0; i < AltLnameFilters.length; i++) {
        AltLnameFilters[i] = (StringFilter) AltLnameFilter[i];
      }
      try {
        out.setAltLnameFilter(AltLnameFilters);
      } catch (Exception x) {
        x.printStackTrace();
      }
    }

    Map AltFnameMap = (Map) record.get("AltFname");
    Boolean AltFnameFetch = DataHelper.getFetch(AltFnameMap);
    Boolean AltFnameSortDir = DataHelper.getSortDirection(AltFnameMap);
    Integer AltFnameSortOrder = DataHelper.getSortOrder(AltFnameMap);
    if (AltFnameFetch != null) out.setAltFnameFetch(AltFnameFetch);
    if (AltFnameSortDir != null) out.setAltFnameSortDirection(AltFnameSortDir);
    if (AltFnameSortOrder != null) out.setAltFnameSortOrder(AltFnameSortOrder);

    Filter[] AltFnameFilter = DataHelper.mapToFilterArray(AltFnameMap, String.class);
    if (AltFnameFilter != null) {
      StringFilter[] AltFnameFilters = new StringFilter[AltFnameFilter.length];
      for (int i = 0; i < AltFnameFilters.length; i++) {
        AltFnameFilters[i] = (StringFilter) AltFnameFilter[i];
      }
      try {
        out.setAltFnameFilter(AltFnameFilters);
      } catch (Exception x) {
        x.printStackTrace();
      }
    }

    Map AltCompanyMap = (Map) record.get("AltCompany");
    Boolean AltCompanyFetch = DataHelper.getFetch(AltCompanyMap);
    Boolean AltCompanySortDir = DataHelper.getSortDirection(AltCompanyMap);
    Integer AltCompanySortOrder = DataHelper.getSortOrder(AltCompanyMap);
    if (AltCompanyFetch != null) out.setAltCompanyFetch(AltCompanyFetch);
    if (AltCompanySortDir != null) out.setAltCompanySortDirection(AltCompanySortDir);
    if (AltCompanySortOrder != null) out.setAltCompanySortOrder(AltCompanySortOrder);

    Filter[] AltCompanyFilter = DataHelper.mapToFilterArray(AltCompanyMap, String.class);
    if (AltCompanyFilter != null) {
      StringFilter[] AltCompanyFilters = new StringFilter[AltCompanyFilter.length];
      for (int i = 0; i < AltCompanyFilters.length; i++) {
        AltCompanyFilters[i] = (StringFilter) AltCompanyFilter[i];
      }
      try {
        out.setAltCompanyFilter(AltCompanyFilters);
      } catch (Exception x) {
        x.printStackTrace();
      }
    }

    Map GenderMap = (Map) record.get("Gender");
    Boolean GenderFetch = DataHelper.getFetch(GenderMap);
    Boolean GenderSortDir = DataHelper.getSortDirection(GenderMap);
    Integer GenderSortOrder = DataHelper.getSortOrder(GenderMap);
    if (GenderFetch != null) out.setGenderFetch(GenderFetch);
    if (GenderSortDir != null) out.setGenderSortDirection(GenderSortDir);
    if (GenderSortOrder != null) out.setGenderSortOrder(GenderSortOrder);

    Filter[] GenderFilter = DataHelper.mapToFilterArray(GenderMap, Integer.class);
    if (GenderFilter != null) {
      IntegerFilter[] GenderFilters = new IntegerFilter[GenderFilter.length];
      for (int i = 0; i < GenderFilters.length; i++) {
        GenderFilters[i] = (IntegerFilter) GenderFilter[i];
      }
      try {
        out.setGenderFilter(GenderFilters);
      } catch (Exception x) {
        x.printStackTrace();
      }
    }

    Map DeptMap = (Map) record.get("Dept");
    Boolean DeptFetch = DataHelper.getFetch(DeptMap);
    Boolean DeptSortDir = DataHelper.getSortDirection(DeptMap);
    Integer DeptSortOrder = DataHelper.getSortOrder(DeptMap);
    if (DeptFetch != null) out.setDeptFetch(DeptFetch);
    if (DeptSortDir != null) out.setDeptSortDirection(DeptSortDir);
    if (DeptSortOrder != null) out.setDeptSortOrder(DeptSortOrder);

    Filter[] DeptFilter = DataHelper.mapToFilterArray(DeptMap, String.class);
    if (DeptFilter != null) {
      StringFilter[] DeptFilters = new StringFilter[DeptFilter.length];
      for (int i = 0; i < DeptFilters.length; i++) {
        DeptFilters[i] = (StringFilter) DeptFilter[i];
      }
      try {
        out.setDeptFilter(DeptFilters);
      } catch (Exception x) {
        x.printStackTrace();
      }
    }

    Map DateActiveMap = (Map) record.get("DateActive");
    Boolean DateActiveFetch = DataHelper.getFetch(DateActiveMap);
    Boolean DateActiveSortDir = DataHelper.getSortDirection(DateActiveMap);
    Integer DateActiveSortOrder = DataHelper.getSortOrder(DateActiveMap);
    if (DateActiveFetch != null) out.setDateActiveFetch(DateActiveFetch);
    if (DateActiveSortDir != null) out.setDateActiveSortDirection(DateActiveSortDir);
    if (DateActiveSortOrder != null) out.setDateActiveSortOrder(DateActiveSortOrder);

    Filter[] DateActiveFilter = DataHelper.mapToFilterArray(DateActiveMap, Date.class);
    if (DateActiveFilter != null) {
      DateFilter[] DateActiveFilters = new DateFilter[DateActiveFilter.length];
      for (int i = 0; i < DateActiveFilters.length; i++) {
        DateActiveFilters[i] = (DateFilter) DateActiveFilter[i];
      }
      try {
        out.setDateActiveFilter(DateActiveFilters);
      } catch (Exception x) {
        x.printStackTrace();
      }
    }

    Map DateInactiveMap = (Map) record.get("DateInactive");
    Boolean DateInactiveFetch = DataHelper.getFetch(DateInactiveMap);
    Boolean DateInactiveSortDir = DataHelper.getSortDirection(DateInactiveMap);
    Integer DateInactiveSortOrder = DataHelper.getSortOrder(DateInactiveMap);
    if (DateInactiveFetch != null) out.setDateInactiveFetch(DateInactiveFetch);
    if (DateInactiveSortDir != null) out.setDateInactiveSortDirection(DateInactiveSortDir);
    if (DateInactiveSortOrder != null) out.setDateInactiveSortOrder(DateInactiveSortOrder);

    Filter[] DateInactiveFilter = DataHelper.mapToFilterArray(DateInactiveMap, Date.class);
    if (DateInactiveFilter != null) {
      DateFilter[] DateInactiveFilters = new DateFilter[DateInactiveFilter.length];
      for (int i = 0; i < DateInactiveFilters.length; i++) {
        DateInactiveFilters[i] = (DateFilter) DateInactiveFilter[i];
      }
      try {
        out.setDateInactiveFilter(DateInactiveFilters);
      } catch (Exception x) {
        x.printStackTrace();
      }
    }

    Map AddressLine1Map = (Map) record.get("AddressLine1");
    Boolean AddressLine1Fetch = DataHelper.getFetch(AddressLine1Map);
    Boolean AddressLine1SortDir = DataHelper.getSortDirection(AddressLine1Map);
    Integer AddressLine1SortOrder = DataHelper.getSortOrder(AddressLine1Map);
    if (AddressLine1Fetch != null) out.setAddressLine1Fetch(AddressLine1Fetch);
    if (AddressLine1SortDir != null) out.setAddressLine1SortDirection(AddressLine1SortDir);
    if (AddressLine1SortOrder != null) out.setAddressLine1SortOrder(AddressLine1SortOrder);

    Filter[] AddressLine1Filter = DataHelper.mapToFilterArray(AddressLine1Map, String.class);
    if (AddressLine1Filter != null) {
      StringFilter[] AddressLine1Filters = new StringFilter[AddressLine1Filter.length];
      for (int i = 0; i < AddressLine1Filters.length; i++) {
        AddressLine1Filters[i] = (StringFilter) AddressLine1Filter[i];
      }
      try {
        out.setAddressLine1Filter(AddressLine1Filters);
      } catch (Exception x) {
        x.printStackTrace();
      }
    }

    Map AddressLine2Map = (Map) record.get("AddressLine2");
    Boolean AddressLine2Fetch = DataHelper.getFetch(AddressLine2Map);
    Boolean AddressLine2SortDir = DataHelper.getSortDirection(AddressLine2Map);
    Integer AddressLine2SortOrder = DataHelper.getSortOrder(AddressLine2Map);
    if (AddressLine2Fetch != null) out.setAddressLine2Fetch(AddressLine2Fetch);
    if (AddressLine2SortDir != null) out.setAddressLine2SortDirection(AddressLine2SortDir);
    if (AddressLine2SortOrder != null) out.setAddressLine2SortOrder(AddressLine2SortOrder);

    Filter[] AddressLine2Filter = DataHelper.mapToFilterArray(AddressLine2Map, String.class);
    if (AddressLine2Filter != null) {
      StringFilter[] AddressLine2Filters = new StringFilter[AddressLine2Filter.length];
      for (int i = 0; i < AddressLine2Filters.length; i++) {
        AddressLine2Filters[i] = (StringFilter) AddressLine2Filter[i];
      }
      try {
        out.setAddressLine2Filter(AddressLine2Filters);
      } catch (Exception x) {
        x.printStackTrace();
      }
    }

    Map AddressLine3Map = (Map) record.get("AddressLine3");
    Boolean AddressLine3Fetch = DataHelper.getFetch(AddressLine3Map);
    Boolean AddressLine3SortDir = DataHelper.getSortDirection(AddressLine3Map);
    Integer AddressLine3SortOrder = DataHelper.getSortOrder(AddressLine3Map);
    if (AddressLine3Fetch != null) out.setAddressLine3Fetch(AddressLine3Fetch);
    if (AddressLine3SortDir != null) out.setAddressLine3SortDirection(AddressLine3SortDir);
    if (AddressLine3SortOrder != null) out.setAddressLine3SortOrder(AddressLine3SortOrder);

    Filter[] AddressLine3Filter = DataHelper.mapToFilterArray(AddressLine3Map, String.class);
    if (AddressLine3Filter != null) {
      StringFilter[] AddressLine3Filters = new StringFilter[AddressLine3Filter.length];
      for (int i = 0; i < AddressLine3Filters.length; i++) {
        AddressLine3Filters[i] = (StringFilter) AddressLine3Filter[i];
      }
      try {
        out.setAddressLine3Filter(AddressLine3Filters);
      } catch (Exception x) {
        x.printStackTrace();
      }
    }

    Map AddressLine4Map = (Map) record.get("AddressLine4");
    Boolean AddressLine4Fetch = DataHelper.getFetch(AddressLine4Map);
    Boolean AddressLine4SortDir = DataHelper.getSortDirection(AddressLine4Map);
    Integer AddressLine4SortOrder = DataHelper.getSortOrder(AddressLine4Map);
    if (AddressLine4Fetch != null) out.setAddressLine4Fetch(AddressLine4Fetch);
    if (AddressLine4SortDir != null) out.setAddressLine4SortDirection(AddressLine4SortDir);
    if (AddressLine4SortOrder != null) out.setAddressLine4SortOrder(AddressLine4SortOrder);

    Filter[] AddressLine4Filter = DataHelper.mapToFilterArray(AddressLine4Map, String.class);
    if (AddressLine4Filter != null) {
      StringFilter[] AddressLine4Filters = new StringFilter[AddressLine4Filter.length];
      for (int i = 0; i < AddressLine4Filters.length; i++) {
        AddressLine4Filters[i] = (StringFilter) AddressLine4Filter[i];
      }
      try {
        out.setAddressLine4Filter(AddressLine4Filters);
      } catch (Exception x) {
        x.printStackTrace();
      }
    }

    Map CityMap = (Map) record.get("City");
    Boolean CityFetch = DataHelper.getFetch(CityMap);
    Boolean CitySortDir = DataHelper.getSortDirection(CityMap);
    Integer CitySortOrder = DataHelper.getSortOrder(CityMap);
    if (CityFetch != null) out.setCityFetch(CityFetch);
    if (CitySortDir != null) out.setCitySortDirection(CitySortDir);
    if (CitySortOrder != null) out.setCitySortOrder(CitySortOrder);

    Filter[] CityFilter = DataHelper.mapToFilterArray(CityMap, String.class);
    if (CityFilter != null) {
      StringFilter[] CityFilters = new StringFilter[CityFilter.length];
      for (int i = 0; i < CityFilters.length; i++) {
        CityFilters[i] = (StringFilter) CityFilter[i];
      }
      try {
        out.setCityFilter(CityFilters);
      } catch (Exception x) {
        x.printStackTrace();
      }
    }

    Map StateMap = (Map) record.get("State");
    Boolean StateFetch = DataHelper.getFetch(StateMap);
    Boolean StateSortDir = DataHelper.getSortDirection(StateMap);
    Integer StateSortOrder = DataHelper.getSortOrder(StateMap);
    if (StateFetch != null) out.setStateFetch(StateFetch);
    if (StateSortDir != null) out.setStateSortDirection(StateSortDir);
    if (StateSortOrder != null) out.setStateSortOrder(StateSortOrder);

    Filter[] StateFilter = DataHelper.mapToFilterArray(StateMap, String.class);
    if (StateFilter != null) {
      StringFilter[] StateFilters = new StringFilter[StateFilter.length];
      for (int i = 0; i < StateFilters.length; i++) {
        StateFilters[i] = (StringFilter) StateFilter[i];
      }
      try {
        out.setStateFilter(StateFilters);
      } catch (Exception x) {
        x.printStackTrace();
      }
    }

    Map PostalCodeMap = (Map) record.get("PostalCode");
    Boolean PostalCodeFetch = DataHelper.getFetch(PostalCodeMap);
    Boolean PostalCodeSortDir = DataHelper.getSortDirection(PostalCodeMap);
    Integer PostalCodeSortOrder = DataHelper.getSortOrder(PostalCodeMap);
    if (PostalCodeFetch != null) out.setPostalCodeFetch(PostalCodeFetch);
    if (PostalCodeSortDir != null) out.setPostalCodeSortDirection(PostalCodeSortDir);
    if (PostalCodeSortOrder != null) out.setPostalCodeSortOrder(PostalCodeSortOrder);

    Filter[] PostalCodeFilter = DataHelper.mapToFilterArray(PostalCodeMap, String.class);
    if (PostalCodeFilter != null) {
      StringFilter[] PostalCodeFilters = new StringFilter[PostalCodeFilter.length];
      for (int i = 0; i < PostalCodeFilters.length; i++) {
        PostalCodeFilters[i] = (StringFilter) PostalCodeFilter[i];
      }
      try {
        out.setPostalCodeFilter(PostalCodeFilters);
      } catch (Exception x) {
        x.printStackTrace();
      }
    }

    Map CountryCodeMap = (Map) record.get("CountryCode");
    Boolean CountryCodeFetch = DataHelper.getFetch(CountryCodeMap);
    Boolean CountryCodeSortDir = DataHelper.getSortDirection(CountryCodeMap);
    Integer CountryCodeSortOrder = DataHelper.getSortOrder(CountryCodeMap);
    if (CountryCodeFetch != null) out.setCountryCodeFetch(CountryCodeFetch);
    if (CountryCodeSortDir != null) out.setCountryCodeSortDirection(CountryCodeSortDir);
    if (CountryCodeSortOrder != null) out.setCountryCodeSortOrder(CountryCodeSortOrder);

    Filter[] CountryCodeFilter = DataHelper.mapToFilterArray(CountryCodeMap, Integer.class);
    if (CountryCodeFilter != null) {
      IntegerFilter[] CountryCodeFilters = new IntegerFilter[CountryCodeFilter.length];
      for (int i = 0; i < CountryCodeFilters.length; i++) {
        CountryCodeFilters[i] = (IntegerFilter) CountryCodeFilter[i];
      }
      try {
        out.setCountryCodeFilter(CountryCodeFilters);
      } catch (Exception x) {
        x.printStackTrace();
      }
    }

    Map FranchiseTaxCodeMap = (Map) record.get("FranchiseTaxCode");
    Boolean FranchiseTaxCodeFetch = DataHelper.getFetch(FranchiseTaxCodeMap);
    Boolean FranchiseTaxCodeSortDir = DataHelper.getSortDirection(FranchiseTaxCodeMap);
    Integer FranchiseTaxCodeSortOrder = DataHelper.getSortOrder(FranchiseTaxCodeMap);
    if (FranchiseTaxCodeFetch != null) out.setFranchiseTaxCodeFetch(FranchiseTaxCodeFetch);
    if (FranchiseTaxCodeSortDir != null)
      out.setFranchiseTaxCodeSortDirection(FranchiseTaxCodeSortDir);
    if (FranchiseTaxCodeSortOrder != null)
      out.setFranchiseTaxCodeSortOrder(FranchiseTaxCodeSortOrder);

    Filter[] FranchiseTaxCodeFilter =
        DataHelper.mapToFilterArray(FranchiseTaxCodeMap, Integer.class);
    if (FranchiseTaxCodeFilter != null) {
      IntegerFilter[] FranchiseTaxCodeFilters = new IntegerFilter[FranchiseTaxCodeFilter.length];
      for (int i = 0; i < FranchiseTaxCodeFilters.length; i++) {
        FranchiseTaxCodeFilters[i] = (IntegerFilter) FranchiseTaxCodeFilter[i];
      }
      try {
        out.setFranchiseTaxCodeFilter(FranchiseTaxCodeFilters);
      } catch (Exception x) {
        x.printStackTrace();
      }
    }

    Map GeocodeMap = (Map) record.get("Geocode");
    Boolean GeocodeFetch = DataHelper.getFetch(GeocodeMap);
    Boolean GeocodeSortDir = DataHelper.getSortDirection(GeocodeMap);
    Integer GeocodeSortOrder = DataHelper.getSortOrder(GeocodeMap);
    if (GeocodeFetch != null) out.setGeocodeFetch(GeocodeFetch);
    if (GeocodeSortDir != null) out.setGeocodeSortDirection(GeocodeSortDir);
    if (GeocodeSortOrder != null) out.setGeocodeSortOrder(GeocodeSortOrder);

    Filter[] GeocodeFilter = DataHelper.mapToFilterArray(GeocodeMap, String.class);
    if (GeocodeFilter != null) {
      StringFilter[] GeocodeFilters = new StringFilter[GeocodeFilter.length];
      for (int i = 0; i < GeocodeFilters.length; i++) {
        GeocodeFilters[i] = (StringFilter) GeocodeFilter[i];
      }
      try {
        out.setGeocodeFilter(GeocodeFilters);
      } catch (Exception x) {
        x.printStackTrace();
      }
    }

    Map CountyMap = (Map) record.get("County");
    Boolean CountyFetch = DataHelper.getFetch(CountyMap);
    Boolean CountySortDir = DataHelper.getSortDirection(CountyMap);
    Integer CountySortOrder = DataHelper.getSortOrder(CountyMap);
    if (CountyFetch != null) out.setCountyFetch(CountyFetch);
    if (CountySortDir != null) out.setCountySortDirection(CountySortDir);
    if (CountySortOrder != null) out.setCountySortOrder(CountySortOrder);

    Filter[] CountyFilter = DataHelper.mapToFilterArray(CountyMap, String.class);
    if (CountyFilter != null) {
      StringFilter[] CountyFilters = new StringFilter[CountyFilter.length];
      for (int i = 0; i < CountyFilters.length; i++) {
        CountyFilters[i] = (StringFilter) CountyFilter[i];
      }
      try {
        out.setCountyFilter(CountyFilters);
      } catch (Exception x) {
        x.printStackTrace();
      }
    }

    return out;
  }
Пример #2
0
  /**
   * convert ContactObjectFilter to a Map (not including the root).
   *
   * @param in the filter to convert to the Map
   * @param record use this Map instead of creating a new one (Optional)
   * @return Map the output Map
   */
  public static Map getMap(ContactObjectFilter in, Map record) {
    Object[] list = null;
    Map map = null;
    if (record == null) record = new HashMap();
    if (in == null) return record;
    if (in._fetch) record.put("Fetch", Boolean.TRUE);

    if (in.Key != null)
      record.put("Key", ContactObjectKeyHelper.getMap(in.Key, (Map) record.get("Key")));
    map =
        DataHelper.filterToMap(
            in.CreateDt, in.CreateDtSort, in.CreateDtSortAscending, in.CreateDtFetch);
    if (map != null) record.put("CreateDt", map);
    map = DataHelper.filterToMap(in.ChgDt, in.ChgDtSort, in.ChgDtSortAscending, in.ChgDtFetch);
    if (map != null) record.put("ChgDt", map);
    map =
        DataHelper.filterToMap(
            in.ChgWho,
            in.ChgWhoSort,
            in.ChgWhoSortAscending,
            in.ChgWhoFetch,
            in.ChgWhoCaseInsensitive);
    if (map != null) record.put("ChgWho", map);
    map =
        DataHelper.filterToMap(
            in.NamePrefix,
            in.NamePrefixSort,
            in.NamePrefixSortAscending,
            in.NamePrefixFetch,
            in.NamePrefixCaseInsensitive);
    if (map != null) record.put("NamePrefix", map);
    map =
        DataHelper.filterToMap(
            in.FirstName,
            in.FirstNameSort,
            in.FirstNameSortAscending,
            in.FirstNameFetch,
            in.FirstNameCaseInsensitive);
    if (map != null) record.put("FirstName", map);
    map =
        DataHelper.filterToMap(
            in.MiddleName,
            in.MiddleNameSort,
            in.MiddleNameSortAscending,
            in.MiddleNameFetch,
            in.MiddleNameCaseInsensitive);
    if (map != null) record.put("MiddleName", map);
    map =
        DataHelper.filterToMap(
            in.LastName,
            in.LastNameSort,
            in.LastNameSortAscending,
            in.LastNameFetch,
            in.LastNameCaseInsensitive);
    if (map != null) record.put("LastName", map);
    map =
        DataHelper.filterToMap(
            in.Generation,
            in.GenerationSort,
            in.GenerationSortAscending,
            in.GenerationFetch,
            in.GenerationCaseInsensitive);
    if (map != null) record.put("Generation", map);
    map =
        DataHelper.filterToMap(
            in.Title, in.TitleSort, in.TitleSortAscending, in.TitleFetch, in.TitleCaseInsensitive);
    if (map != null) record.put("Title", map);
    map =
        DataHelper.filterToMap(
            in.Company,
            in.CompanySort,
            in.CompanySortAscending,
            in.CompanyFetch,
            in.CompanyCaseInsensitive);
    if (map != null) record.put("Company", map);
    map =
        DataHelper.filterToMap(
            in.AddressId, in.AddressIdSort, in.AddressIdSortAscending, in.AddressIdFetch);
    if (map != null) record.put("AddressId", map);
    map =
        DataHelper.filterToMap(
            in.AltLname,
            in.AltLnameSort,
            in.AltLnameSortAscending,
            in.AltLnameFetch,
            in.AltLnameCaseInsensitive);
    if (map != null) record.put("AltLname", map);
    map =
        DataHelper.filterToMap(
            in.AltFname,
            in.AltFnameSort,
            in.AltFnameSortAscending,
            in.AltFnameFetch,
            in.AltFnameCaseInsensitive);
    if (map != null) record.put("AltFname", map);
    map =
        DataHelper.filterToMap(
            in.AltCompany,
            in.AltCompanySort,
            in.AltCompanySortAscending,
            in.AltCompanyFetch,
            in.AltCompanyCaseInsensitive);
    if (map != null) record.put("AltCompany", map);
    map = DataHelper.filterToMap(in.Gender, in.GenderSort, in.GenderSortAscending, in.GenderFetch);
    if (map != null) record.put("Gender", map);
    map =
        DataHelper.filterToMap(
            in.Dept, in.DeptSort, in.DeptSortAscending, in.DeptFetch, in.DeptCaseInsensitive);
    if (map != null) record.put("Dept", map);
    map =
        DataHelper.filterToMap(
            in.DateActive, in.DateActiveSort, in.DateActiveSortAscending, in.DateActiveFetch);
    if (map != null) record.put("DateActive", map);
    map =
        DataHelper.filterToMap(
            in.DateInactive,
            in.DateInactiveSort,
            in.DateInactiveSortAscending,
            in.DateInactiveFetch);
    if (map != null) record.put("DateInactive", map);
    map =
        DataHelper.filterToMap(
            in.AddressLine1,
            in.AddressLine1Sort,
            in.AddressLine1SortAscending,
            in.AddressLine1Fetch,
            in.AddressLine1CaseInsensitive);
    if (map != null) record.put("AddressLine1", map);
    map =
        DataHelper.filterToMap(
            in.AddressLine2,
            in.AddressLine2Sort,
            in.AddressLine2SortAscending,
            in.AddressLine2Fetch,
            in.AddressLine2CaseInsensitive);
    if (map != null) record.put("AddressLine2", map);
    map =
        DataHelper.filterToMap(
            in.AddressLine3,
            in.AddressLine3Sort,
            in.AddressLine3SortAscending,
            in.AddressLine3Fetch,
            in.AddressLine3CaseInsensitive);
    if (map != null) record.put("AddressLine3", map);
    map =
        DataHelper.filterToMap(
            in.AddressLine4,
            in.AddressLine4Sort,
            in.AddressLine4SortAscending,
            in.AddressLine4Fetch,
            in.AddressLine4CaseInsensitive);
    if (map != null) record.put("AddressLine4", map);
    map =
        DataHelper.filterToMap(
            in.City, in.CitySort, in.CitySortAscending, in.CityFetch, in.CityCaseInsensitive);
    if (map != null) record.put("City", map);
    map =
        DataHelper.filterToMap(
            in.State, in.StateSort, in.StateSortAscending, in.StateFetch, in.StateCaseInsensitive);
    if (map != null) record.put("State", map);
    map =
        DataHelper.filterToMap(
            in.PostalCode,
            in.PostalCodeSort,
            in.PostalCodeSortAscending,
            in.PostalCodeFetch,
            in.PostalCodeCaseInsensitive);
    if (map != null) record.put("PostalCode", map);
    map =
        DataHelper.filterToMap(
            in.CountryCode, in.CountryCodeSort, in.CountryCodeSortAscending, in.CountryCodeFetch);
    if (map != null) record.put("CountryCode", map);
    map =
        DataHelper.filterToMap(
            in.FranchiseTaxCode,
            in.FranchiseTaxCodeSort,
            in.FranchiseTaxCodeSortAscending,
            in.FranchiseTaxCodeFetch);
    if (map != null) record.put("FranchiseTaxCode", map);
    map =
        DataHelper.filterToMap(
            in.Geocode,
            in.GeocodeSort,
            in.GeocodeSortAscending,
            in.GeocodeFetch,
            in.GeocodeCaseInsensitive);
    if (map != null) record.put("Geocode", map);
    map =
        DataHelper.filterToMap(
            in.County,
            in.CountySort,
            in.CountySortAscending,
            in.CountyFetch,
            in.CountyCaseInsensitive);
    if (map != null) record.put("County", map);
    return record;
  }
Пример #3
0
  /**
   * convert Map to ContactObjectData.
   *
   * @param record the Map containing the data to convert to the object, not including the root
   * @return ContactObjectData the converted object
   */
  public static ContactObjectData getObj(Map record) {
    Object[] list = null;
    Object obj = null;
    if (record == null) return null;
    ContactObjectData out = new ContactObjectData();

    out.Key = ContactObjectKeyHelper.getObj((Map) record.get("Key"));
    if ((obj = record.get("CreateDt")) != null) {
      out.CreateDt = (Date) obj;
    }

    if ((obj = record.get("ChgDt")) != null) {
      out.ChgDt = (Date) obj;
    }

    if ((obj = record.get("ChgWho")) != null) {
      out.ChgWho = (String) obj;
    }

    if ((obj = record.get("NamePrefix")) != null) {
      out.NamePrefix = (String) obj;
    }

    if ((obj = record.get("FirstName")) != null) {
      out.FirstName = (String) obj;
    }

    if ((obj = record.get("MiddleName")) != null) {
      out.MiddleName = (String) obj;
    }

    if ((obj = record.get("LastName")) != null) {
      out.LastName = (String) obj;
    }

    if ((obj = record.get("Generation")) != null) {
      out.Generation = (String) obj;
    }

    if ((obj = record.get("Title")) != null) {
      out.Title = (String) obj;
    }

    if ((obj = record.get("Company")) != null) {
      out.Company = (String) obj;
    }

    if ((obj = record.get("AddressId")) != null) {
      out.AddressId = (BigInteger) obj;
    }

    if ((obj = record.get("AltLname")) != null) {
      out.AltLname = (String) obj;
    }

    if ((obj = record.get("AltFname")) != null) {
      out.AltFname = (String) obj;
    }

    if ((obj = record.get("AltCompany")) != null) {
      out.AltCompany = (String) obj;
    }

    if ((obj = record.get("Gender")) != null) {
      out.Gender = (Integer) obj;
    }

    if ((obj = record.get("Dept")) != null) {
      out.Dept = (String) obj;
    }

    if ((obj = record.get("DateActive")) != null) {
      out.DateActive = (Date) obj;
    }

    if ((obj = record.get("DateInactive")) != null) {
      out.DateInactive = (Date) obj;
    }

    if ((obj = record.get("AddressLine1")) != null) {
      out.AddressLine1 = (String) obj;
    }

    if ((obj = record.get("AddressLine2")) != null) {
      out.AddressLine2 = (String) obj;
    }

    if ((obj = record.get("AddressLine3")) != null) {
      out.AddressLine3 = (String) obj;
    }

    if ((obj = record.get("AddressLine4")) != null) {
      out.AddressLine4 = (String) obj;
    }

    if ((obj = record.get("City")) != null) {
      out.City = (String) obj;
    }

    if ((obj = record.get("State")) != null) {
      out.State = (String) obj;
    }

    if ((obj = record.get("PostalCode")) != null) {
      out.PostalCode = (String) obj;
    }

    if ((obj = record.get("CountryCode")) != null) {
      out.CountryCode = (Integer) obj;
    }

    if ((obj = record.get("FranchiseTaxCode")) != null) {
      out.FranchiseTaxCode = (Integer) obj;
    }

    if ((obj = record.get("Geocode")) != null) {
      out.Geocode = (String) obj;
    }

    if ((obj = record.get("County")) != null) {
      out.County = (String) obj;
    }
    return out;
  }
Пример #4
0
  /**
   * convert ContactObjectData to a Map (not including the root).
   *
   * @param in the object to convert to the Map
   * @param record use this Map instead of creating a new one (Optional)
   * @return Map the output Map
   */
  public static Map getMap(ContactObjectData in, Map record) {
    Object[] list = null;
    if (record == null) record = new HashMap();
    if (in == null) return record;

    if (in.Key != null)
      record.put("Key", ContactObjectKeyHelper.getMap(in.Key, (Map) record.get("Key")));
    if (in._CreateDtSet) record.put("CreateDt", in.CreateDt);

    if (in._ChgDtSet) record.put("ChgDt", in.ChgDt);

    if (in._ChgWhoSet) record.put("ChgWho", in.ChgWho);

    if (in._NamePrefixSet) record.put("NamePrefix", in.NamePrefix);

    if (in._FirstNameSet) record.put("FirstName", in.FirstName);

    if (in._MiddleNameSet) record.put("MiddleName", in.MiddleName);

    if (in._LastNameSet) record.put("LastName", in.LastName);

    if (in._GenerationSet) record.put("Generation", in.Generation);

    if (in._TitleSet) record.put("Title", in.Title);

    if (in._CompanySet) record.put("Company", in.Company);

    if (in._AddressIdSet) record.put("AddressId", in.AddressId);

    if (in._AltLnameSet) record.put("AltLname", in.AltLname);

    if (in._AltFnameSet) record.put("AltFname", in.AltFname);

    if (in._AltCompanySet) record.put("AltCompany", in.AltCompany);

    if (in._GenderSet) record.put("Gender", in.Gender);

    if (in._DeptSet) record.put("Dept", in.Dept);

    if (in._DateActiveSet) record.put("DateActive", in.DateActive);

    if (in._DateInactiveSet) record.put("DateInactive", in.DateInactive);

    if (in._AddressLine1Set) record.put("AddressLine1", in.AddressLine1);

    if (in._AddressLine2Set) record.put("AddressLine2", in.AddressLine2);

    if (in._AddressLine3Set) record.put("AddressLine3", in.AddressLine3);

    if (in._AddressLine4Set) record.put("AddressLine4", in.AddressLine4);

    if (in._CitySet) record.put("City", in.City);

    if (in._StateSet) record.put("State", in.State);

    if (in._PostalCodeSet) record.put("PostalCode", in.PostalCode);

    if (in._CountryCodeSet) record.put("CountryCode", in.CountryCode);

    if (in._FranchiseTaxCodeSet) record.put("FranchiseTaxCode", in.FranchiseTaxCode);

    if (in._GeocodeSet) record.put("Geocode", in.Geocode);

    if (in._CountySet) record.put("County", in.County);
    return record;
  }