@Test
 public void lengthExceedLimit() {
   eventStore.onEvent(
       create(
           System.currentTimeMillis() - 30000,
           EventType.LOGIN,
           "realmId",
           StringUtils.repeat("clientId", 100),
           "userId",
           "127.0.0.1",
           "error"));
   eventStore.onEvent(
       create(
           System.currentTimeMillis() - 30000,
           EventType.LOGIN,
           StringUtils.repeat("realmId", 100),
           "clientId",
           "userId",
           "127.0.0.1",
           "error"));
   eventStore.onEvent(
       create(
           System.currentTimeMillis() - 30000,
           EventType.LOGIN,
           "realmId",
           "clientId",
           StringUtils.repeat("userId", 100),
           "127.0.0.1",
           "error"));
 }
  /** Delete all admin events */
  @Path("admin-events")
  @DELETE
  public void clearAdminEvents() {
    auth.init(RealmAuth.Resource.EVENTS).requireManage();

    EventStoreProvider eventStore = session.getProvider(EventStoreProvider.class);
    eventStore.clearAdmin(realm.getId());
  }
Beispiel #3
0
 @Path("log")
 @GET
 public Response logPage() {
   if (auth != null) {
     List<Event> events =
         eventStore
             .createQuery()
             .type(LOG_EVENTS)
             .user(auth.getUser().getId())
             .maxResults(30)
             .getResultList();
     for (Event e : events) {
       if (e.getDetails() != null) {
         Iterator<Map.Entry<String, String>> itr = e.getDetails().entrySet().iterator();
         while (itr.hasNext()) {
           if (!LOG_DETAILS.contains(itr.next().getKey())) {
             itr.remove();
           }
         }
       }
     }
     account.setEvents(events);
   }
   return forwardToPage("log", AccountPages.LOG);
 }
 @Test
 public void maxLengthWithNull() {
   eventStore.onEvent(
       create(
           System.currentTimeMillis() - 30000,
           EventType.LOGIN,
           null,
           null,
           null,
           "127.0.0.1",
           "error"));
 }
  @Test
  public void clearOld() {
    eventStore.onEvent(
        create(
            System.currentTimeMillis() - 30000,
            EventType.LOGIN,
            "realmId",
            "clientId",
            "userId",
            "127.0.0.1",
            "error"));
    eventStore.onEvent(
        create(
            System.currentTimeMillis() - 20000,
            EventType.LOGIN,
            "realmId",
            "clientId",
            "userId",
            "127.0.0.1",
            "error"));
    eventStore.onEvent(
        create(
            System.currentTimeMillis(),
            EventType.LOGIN,
            "realmId",
            "clientId",
            "userId",
            "127.0.0.1",
            "error"));
    eventStore.onEvent(
        create(
            System.currentTimeMillis(),
            EventType.LOGIN,
            "realmId",
            "clientId",
            "userId",
            "127.0.0.1",
            "error"));
    eventStore.onEvent(
        create(
            System.currentTimeMillis() - 30000,
            EventType.LOGIN,
            "realmId2",
            "clientId",
            "userId",
            "127.0.0.1",
            "error"));

    resetSession();

    eventStore.clear("realmId", System.currentTimeMillis() - 10000);

    Assert.assertEquals(3, eventStore.createQuery().getResultList().size());
  }
  @Test
  public void query() {
    long oldest = System.currentTimeMillis() - 30000;
    long newest = System.currentTimeMillis() + 30000;

    eventStore.onEvent(
        create(EventType.LOGIN, "realmId", "clientId", "userId", "127.0.0.1", "error"));
    eventStore.onEvent(
        create(newest, EventType.REGISTER, "realmId", "clientId", "userId", "127.0.0.1", "error"));
    eventStore.onEvent(
        create(newest, EventType.REGISTER, "realmId", "clientId", "userId2", "127.0.0.1", "error"));
    eventStore.onEvent(
        create(EventType.LOGIN, "realmId2", "clientId", "userId", "127.0.0.1", "error"));
    eventStore.onEvent(
        create(oldest, EventType.LOGIN, "realmId", "clientId2", "userId", "127.0.0.1", "error"));
    eventStore.onEvent(
        create(EventType.LOGIN, "realmId", "clientId", "userId2", "127.0.0.1", "error"));

    resetSession();

    Assert.assertEquals(5, eventStore.createQuery().client("clientId").getResultList().size());
    Assert.assertEquals(5, eventStore.createQuery().realm("realmId").getResultList().size());
    Assert.assertEquals(4, eventStore.createQuery().type(EventType.LOGIN).getResultList().size());
    Assert.assertEquals(
        6,
        eventStore.createQuery().type(EventType.LOGIN, EventType.REGISTER).getResultList().size());
    Assert.assertEquals(4, eventStore.createQuery().user("userId").getResultList().size());

    Assert.assertEquals(
        1, eventStore.createQuery().user("userId").type(EventType.REGISTER).getResultList().size());

    Assert.assertEquals(2, eventStore.createQuery().maxResults(2).getResultList().size());
    Assert.assertEquals(1, eventStore.createQuery().firstResult(5).getResultList().size());

    Assert.assertEquals(
        newest, eventStore.createQuery().maxResults(1).getResultList().get(0).getTime());
    Assert.assertEquals(
        oldest,
        eventStore.createQuery().firstResult(5).maxResults(1).getResultList().get(0).getTime());

    eventStore.clear("realmId");
    eventStore.clear("realmId2");

    Assert.assertEquals(0, eventStore.createQuery().getResultList().size());

    String d1 = new String("2015-03-04");
    String d2 = new String("2015-03-05");
    String d3 = new String("2015-03-06");
    String d4 = new String("2015-03-07");

    String d5 = new String("2015-03-01");
    String d6 = new String("2015-03-03");
    String d7 = new String("2015-03-08");
    String d8 = new String("2015-03-10");

    SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
    Date date1 = null, date2 = null, date3 = null, date4 = null;
    Date date5 = null, date6 = null, date7 = null, date8 = null;

    try {
      date1 = formatter.parse(d1);
      date2 = formatter.parse(d2);
      date3 = formatter.parse(d3);
      date4 = formatter.parse(d4);

      date5 = formatter.parse(d5);
      date6 = formatter.parse(d6);
      date7 = formatter.parse(d7);
      date8 = formatter.parse(d8);
    } catch (ParseException e) {
      e.printStackTrace();
    }

    eventStore.onEvent(
        create(date1, EventType.LOGIN, "realmId", "clientId", "userId", "127.0.0.1", "error"));
    eventStore.onEvent(
        create(date1, EventType.LOGIN, "realmId", "clientId", "userId", "127.0.0.1", "error"));
    eventStore.onEvent(
        create(date2, EventType.REGISTER, "realmId", "clientId", "userId", "127.0.0.1", "error"));
    eventStore.onEvent(
        create(date2, EventType.REGISTER, "realmId", "clientId", "userId", "127.0.0.1", "error"));
    eventStore.onEvent(
        create(
            date3,
            EventType.CODE_TO_TOKEN,
            "realmId",
            "clientId",
            "userId2",
            "127.0.0.1",
            "error"));
    eventStore.onEvent(
        create(date3, EventType.LOGOUT, "realmId", "clientId", "userId2", "127.0.0.1", "error"));
    eventStore.onEvent(
        create(
            date4,
            EventType.UPDATE_PROFILE,
            "realmId2",
            "clientId2",
            "userId2",
            "127.0.0.1",
            "error"));
    eventStore.onEvent(
        create(
            date4,
            EventType.UPDATE_EMAIL,
            "realmId2",
            "clientId2",
            "userId2",
            "127.0.0.1",
            "error"));

    resetSession();

    Assert.assertEquals(6, eventStore.createQuery().client("clientId").getResultList().size());
    Assert.assertEquals(2, eventStore.createQuery().client("clientId2").getResultList().size());

    Assert.assertEquals(6, eventStore.createQuery().realm("realmId").getResultList().size());
    Assert.assertEquals(2, eventStore.createQuery().realm("realmId2").getResultList().size());

    Assert.assertEquals(4, eventStore.createQuery().user("userId").getResultList().size());
    Assert.assertEquals(4, eventStore.createQuery().user("userId2").getResultList().size());

    Assert.assertEquals(2, eventStore.createQuery().type(EventType.LOGIN).getResultList().size());
    Assert.assertEquals(
        2, eventStore.createQuery().type(EventType.REGISTER).getResultList().size());
    Assert.assertEquals(
        4,
        eventStore.createQuery().type(EventType.LOGIN, EventType.REGISTER).getResultList().size());
    Assert.assertEquals(
        1, eventStore.createQuery().type(EventType.CODE_TO_TOKEN).getResultList().size());
    Assert.assertEquals(1, eventStore.createQuery().type(EventType.LOGOUT).getResultList().size());
    Assert.assertEquals(
        1, eventStore.createQuery().type(EventType.UPDATE_PROFILE).getResultList().size());
    Assert.assertEquals(
        1, eventStore.createQuery().type(EventType.UPDATE_EMAIL).getResultList().size());

    Assert.assertEquals(8, eventStore.createQuery().fromDate(date1).getResultList().size());
    Assert.assertEquals(8, eventStore.createQuery().toDate(date4).getResultList().size());

    Assert.assertEquals(4, eventStore.createQuery().fromDate(date3).getResultList().size());
    Assert.assertEquals(4, eventStore.createQuery().toDate(date2).getResultList().size());

    Assert.assertEquals(0, eventStore.createQuery().fromDate(date7).getResultList().size());
    Assert.assertEquals(0, eventStore.createQuery().toDate(date6).getResultList().size());

    Assert.assertEquals(
        8, eventStore.createQuery().fromDate(date1).toDate(date4).getResultList().size());
    Assert.assertEquals(
        6, eventStore.createQuery().fromDate(date2).toDate(date4).getResultList().size());
    Assert.assertEquals(
        4, eventStore.createQuery().fromDate(date1).toDate(date2).getResultList().size());
    Assert.assertEquals(
        4, eventStore.createQuery().fromDate(date3).toDate(date4).getResultList().size());

    Assert.assertEquals(
        0, eventStore.createQuery().fromDate(date5).toDate(date6).getResultList().size());
    Assert.assertEquals(
        0, eventStore.createQuery().fromDate(date7).toDate(date8).getResultList().size());
  }
 @Test
 public void save() {
   eventStore.onEvent(
       create(EventType.LOGIN, "realmId", "clientId", "userId", "127.0.0.1", "error"));
 }
 @After
 public void after() {
   eventStore.clear();
   kc.stopSession(session, true);
 }
  /**
   * Get admin events
   *
   * <p>Returns all admin events, or filters events based on URL query parameters listed here
   *
   * @param operationTypes
   * @param authRealm
   * @param authClient
   * @param authUser user id
   * @param authIpAddress
   * @param resourcePath
   * @param dateTo
   * @param dateFrom
   * @param firstResult
   * @param maxResults
   * @return
   */
  @Path("admin-events")
  @GET
  @NoCache
  @Produces(MediaType.APPLICATION_JSON)
  public List<AdminEventRepresentation> getEvents(
      @QueryParam("operationTypes") List<String> operationTypes,
      @QueryParam("authRealm") String authRealm,
      @QueryParam("authClient") String authClient,
      @QueryParam("authUser") String authUser,
      @QueryParam("authIpAddress") String authIpAddress,
      @QueryParam("resourcePath") String resourcePath,
      @QueryParam("dateFrom") String dateFrom,
      @QueryParam("dateTo") String dateTo,
      @QueryParam("first") Integer firstResult,
      @QueryParam("max") Integer maxResults,
      @QueryParam("resourceTypes") List<String> resourceTypes) {
    auth.init(RealmAuth.Resource.EVENTS).requireView();

    EventStoreProvider eventStore = session.getProvider(EventStoreProvider.class);
    AdminEventQuery query = eventStore.createAdminQuery().realm(realm.getId());
    ;

    if (authRealm != null) {
      query.authRealm(authRealm);
    }

    if (authClient != null) {
      query.authClient(authClient);
    }

    if (authUser != null) {
      query.authUser(authUser);
    }

    if (authIpAddress != null) {
      query.authIpAddress(authIpAddress);
    }

    if (resourcePath != null) {
      query.resourcePath(resourcePath);
    }

    if (operationTypes != null && !operationTypes.isEmpty()) {
      OperationType[] t = new OperationType[operationTypes.size()];
      for (int i = 0; i < t.length; i++) {
        t[i] = OperationType.valueOf(operationTypes.get(i));
      }
      query.operation(t);
    }

    if (resourceTypes != null && !resourceTypes.isEmpty()) {
      ResourceType[] t = new ResourceType[resourceTypes.size()];
      for (int i = 0; i < t.length; i++) {
        t[i] = ResourceType.valueOf(resourceTypes.get(i));
      }
      query.resourceType(t);
    }

    if (dateFrom != null) {
      SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
      Date from = null;
      try {
        from = df.parse(dateFrom);
      } catch (ParseException e) {
        throw new BadRequestException(
            "Invalid value for 'Date(From)', expected format is yyyy-MM-dd");
      }
      query.fromTime(from);
    }

    if (dateTo != null) {
      SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
      Date to = null;
      try {
        to = df.parse(dateTo);
      } catch (ParseException e) {
        throw new BadRequestException(
            "Invalid value for 'Date(To)', expected format is yyyy-MM-dd");
      }
      query.toTime(to);
    }

    if (firstResult != null) {
      query.firstResult(firstResult);
    }
    if (maxResults != null) {
      query.maxResults(maxResults);
    }

    return toAdminEventRep(query.getResultList());
  }
  /**
   * Get events
   *
   * <p>Returns all events, or filters them based on URL query parameters listed here
   *
   * @param types The types of events to return
   * @param client App or oauth client name
   * @param user User id
   * @param ipAddress IP address
   * @param dateTo To date
   * @param dateFrom From date
   * @param firstResult Paging offset
   * @param maxResults Paging size
   * @return
   */
  @Path("events")
  @GET
  @NoCache
  @Produces(MediaType.APPLICATION_JSON)
  public List<EventRepresentation> getEvents(
      @QueryParam("type") List<String> types,
      @QueryParam("client") String client,
      @QueryParam("user") String user,
      @QueryParam("dateFrom") String dateFrom,
      @QueryParam("dateTo") String dateTo,
      @QueryParam("ipAddress") String ipAddress,
      @QueryParam("first") Integer firstResult,
      @QueryParam("max") Integer maxResults) {
    auth.init(RealmAuth.Resource.EVENTS).requireView();

    EventStoreProvider eventStore = session.getProvider(EventStoreProvider.class);

    EventQuery query = eventStore.createQuery().realm(realm.getId());
    if (client != null) {
      query.client(client);
    }

    if (types != null & !types.isEmpty()) {
      EventType[] t = new EventType[types.size()];
      for (int i = 0; i < t.length; i++) {
        t[i] = EventType.valueOf(types.get(i));
      }
      query.type(t);
    }

    if (user != null) {
      query.user(user);
    }

    if (dateFrom != null) {
      SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
      Date from = null;
      try {
        from = df.parse(dateFrom);
      } catch (ParseException e) {
        throw new BadRequestException(
            "Invalid value for 'Date(From)', expected format is yyyy-MM-dd");
      }
      query.fromDate(from);
    }

    if (dateTo != null) {
      SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
      Date to = null;
      try {
        to = df.parse(dateTo);
      } catch (ParseException e) {
        throw new BadRequestException(
            "Invalid value for 'Date(To)', expected format is yyyy-MM-dd");
      }
      query.toDate(to);
    }

    if (ipAddress != null) {
      query.ipAddress(ipAddress);
    }
    if (firstResult != null) {
      query.firstResult(firstResult);
    }
    if (maxResults != null) {
      query.maxResults(maxResults);
    }

    return toEventListRep(query.getResultList());
  }