clouway / cuse Goto Github PK

 for (Address address : addresses) {
      searchEngine.register(new AddressIndex(address));
    }

  searchEngine.registerAll(addressIndexes);

// Query: "(deletedOn >= :nextDay or deleted:true)"

public class TextIndex {
  private final Set<String> words;

  public TextIndex(String... words) {
    this.words = newLinkedHashSet(newArrayList(words));
  }

  public List<String> generate() {
    Set<String> index = newLinkedHashSet();

    for (String word : words) {
      word = word.toUpperCase();

      for (int i = 0; i < word.length(); i++) {
        for (int j = i + 1; j < word.length(); j++) {
          index.add(word.substring(i, j));
        }

        index.add(word.substring(i));
      }
    }

    return newArrayList(index);
  }
}

public class SearchIndexStrategy implements IndexingStrategy<SearchIndex> {

  @Override
  public String getIndexName() {
    return SearchIndex.class.getSimpleName();
  }

  @Override
  public String getId(SearchIndex index) {
    return String.valueOf(index.getId());
  }

  @Override
  public IndexingSchema getIndexingSchema() {
    return IndexingSchema.aNewIndexingSchema()
            .fields("id", "state", "creationDate", "tags", "operationZones")
            .fullTextFields("city", "street", "customer")
            .build();
  }

 @SearchIndex("SearchIndex")
 public class SearchIndex {
  @SearchIndexId
  private Long id;

  @FullWordSearch
  private String city;

  @FullTextSearch
  private String street;

  @FullWordSearch
  private String customer;

  private String state;

  @SearchableDate
  private Date creationDate;

  private List<String> tags = Lists.newArrayList();
  private List<Long> operationZones = Lists.newArrayList();


  public SearchIndex(Object object) {
    id = object.getId();
    operationZones = Lists.newArrayList(object.getOperationZoneIds());

    if (object.getState() != null) {
      state = object.getState().getState();
    }

    if (object.getCreationInfo() != null) {
      creationDate = object.getCreationInfo().getCreationDate();
    }

    if (object.getTags() != null) {
      tags = Lists.newArrayList(object.getTags());
    }

    //the post code should be separated property and not full text search , for better search
    Address serviceAddress = object.getServiceAddress();
    if (serviceAddress != null) {
      city = serviceAddress.getCityLine();
      street = serviceAddress.getAddressLine();
    }

    if (object.getClient() != null) {
      String customerLine = ObjectLineBuilder.line()
              .wordSuf(object.getClient().getNameLine(), " ")
              .wordSuf(object.getClient().getEmail(), " ")
              .wordSuf(object.getClient().getTelephone(), " ")
              .build();

      customer = customerLine;
    }

  }

//not sure that we will need this when we have @SearchIndexId annotation
  public Long getId() {
    return id;
  }
}

  @Test
  public void sortConsecutiveRecordsByDateAndPassedOffsetAsc() {

    store(aNewEmployee().id(1l).birthDate(aNewDate(2014, 1, 3)).build());
    store(aNewEmployee().id(2l).birthDate(aNewDate(2014, 1, 5)).build());
    store(aNewEmployee().id(3l).birthDate(aNewDate(2014, 1, 8)).build());
    store(aNewEmployee().id(4l).birthDate(aNewDate(2014, 1, 13)).build());
    store(aNewEmployee().id(5l).birthDate(aNewDate(2014, 1, 21)).build());

    List<Employee> result = searchEngine.search(Employee.class)
            .sortBy("birthDate", SortOrder.ASCENDING, SortType.NUMERIC)
            .offset(2)
            .returnAll()
            .now();

    assertThat(result.size(), is(3));
    assertThat(result.get(0).id, is(3l));
    assertThat(result.get(1).id, is(4l));
    assertThat(result.get(2).id, is(5l));
  }

  @Test
  public void sortNonConsecutiveRecordsByDateAndPassedOffsetAsc() {

    store(aNewEmployee().id(5l).birthDate(aNewDate(2014, 1, 21)).build());
    store(aNewEmployee().id(2l).birthDate(aNewDate(2014, 1, 5)).build());
    store(aNewEmployee().id(4l).birthDate(aNewDate(2014, 1, 13)).build());
    store(aNewEmployee().id(1l).birthDate(aNewDate(2014, 1, 3)).build());
    store(aNewEmployee().id(3l).birthDate(aNewDate(2014, 1, 8)).build());

    List<Employee> result = searchEngine.search(Employee.class)
            .sortBy("birthDate", SortOrder.ASCENDING, SortType.NUMERIC)
            .offset(4)
            .returnAll()
            .now();

    assertThat(result.size(), is(1));
    assertThat(result.get(0).id, is(5l));
  }

  @Test
  public void sortConsecutiveRecordsByDateAndPassedOffsetDesc() {

    store(aNewEmployee().id(1l).birthDate(aNewDate(2014, 1, 5)).build());
    store(aNewEmployee().id(2l).birthDate(aNewDate(2014, 1, 10)).build());
    store(aNewEmployee().id(3l).birthDate(aNewDate(2014, 1, 15)).build());
    store(aNewEmployee().id(4l).birthDate(aNewDate(2014, 1, 4)).build());

    List<Employee> result = searchEngine.search(Employee.class)
            .sortBy("birthDate", SortOrder.DESCENDING, SortType.NUMERIC)
            .offset(1)
            .fetchMaximum(10)
            .now();

    assertThat(result.size(), is(3));
    assertThat(result.get(0).id, is(2l));
    assertThat(result.get(1).id, is(1l));
  }

  @Test
  public void sortNonConsecutiveRecordsByDateAndPassedOffsetDesc() {

    store(aNewEmployee().id(2l).birthDate(aNewDate(2014, 1, 10)).build());
    store(aNewEmployee().id(4l).birthDate(aNewDate(2014, 1, 4)).build());
    store(aNewEmployee().id(1l).birthDate(aNewDate(2014, 1, 5)).build());
    store(aNewEmployee().id(3l).birthDate(aNewDate(2014, 1, 15)).build());

    List<Employee> result = searchEngine.search(Employee.class)
            .sortBy("birthDate", SortOrder.DESCENDING, SortType.NUMERIC)
            .offset(2)
            .fetchMaximum(10)
            .now();

    assertThat(result.size(), is(2));
    assertThat(result.get(0).id, is(1l));
    assertThat(result.get(1).id, is(4l));
  }

@Test
  public void searchForFieldThatContainsUnderscore() {

    store(aNewEmployee().id(1l).firstName("John Adam").build());
    store(aNewEmployee().id(2l).firstName("John_Adam").build());

    List<Employee> result = searchEngine.search(Employee.class).where("firstName", SearchFilters.is("John")).returnAll().now();

    assertThat(result.size(), is(1));
  }

@SearchIndex(name = "DeviceIndex")
public class DeviceIndex {
  @SearchId
  private Long id;
  private String type;
  ...
  @DynamicFields  // example new annotation for this purpose
  private Map<String, String> fields; //{"fieldName1": "value1", "fieldName2": "value2", ...}
  ...
}

  @Ignore
  @SearchId
  private String id;

searchEngine.get().delete("indexName", addressIds);

...
String getIndesName();
...

class MyIndex {
   private DateTime creationTime; 
}

...

GaeSearchApiCuseModule module = new GaeSearchApiCuseModule(TwigEntityLoader.class); 

module.registerTypeConverter(new Converter<DateTime,Date>() {
   public Date convert(DateTime dateTime) {
       if (dateTime == null) {
            return null; 
       }
       return dateTime.getDate();
   }
} 

public TeamIndex(Team team){
    this.id = team.getId();
    this.locationIds = team.getLocationIds();
    this.departmentIds = team.getDepartmentIds();
    if(team.getDeletedOn() != null) {
      this.deletedOn = team.getDeletedOn().getDate();
    }