Examples with AnnouncementUserGroup fi.otavanopisto.muikku.plugins.announcer.model.AnnouncementUserGroup used on opensource projects

Example 1 with AnnouncementUserGroup

use of fi.otavanopisto.muikku.plugins.announcer.model.AnnouncementUserGroup in project muikku by otavanopisto.

the class AnnouncerRESTService method listAnnouncements.

@GET
@Path("/announcements")
@RESTPermit(handling = Handling.INLINE)
public Response listAnnouncements(@QueryParam("hideEnvironmentAnnouncements") @DefaultValue("false") boolean hideEnvironmentAnnouncements, @QueryParam("hideWorkspaceAnnouncements") @DefaultValue("false") boolean hideWorkspaceAnnouncements, @QueryParam("hideGroupAnnouncements") @DefaultValue("false") boolean hideGroupAnnouncements, @QueryParam("workspaceEntityId") Long workspaceEntityId, @QueryParam("onlyMine") @DefaultValue("false") boolean onlyMine, @QueryParam("onlyEditable") @DefaultValue("false") boolean onlyEditable, @QueryParam("onlyArchived") @DefaultValue("false") boolean onlyArchived, @QueryParam("timeFrame") @DefaultValue("CURRENT") AnnouncementTimeFrame timeFrame) {
    UserEntity currentUserEntity = sessionController.getLoggedUserEntity();
    if (currentUserEntity == null) {
        return Response.noContent().build();
    }
    List<Announcement> announcements = null;
    AnnouncementEnvironmentRestriction environment = hideEnvironmentAnnouncements ? AnnouncementEnvironmentRestriction.NONE : sessionController.hasEnvironmentPermission(AnnouncerPermissions.LIST_ENVIRONMENT_GROUP_ANNOUNCEMENTS) ? AnnouncementEnvironmentRestriction.PUBLICANDGROUP : AnnouncementEnvironmentRestriction.PUBLIC;
    if (workspaceEntityId == null) {
        boolean includeGroups = !hideGroupAnnouncements;
        boolean includeWorkspaces = !hideWorkspaceAnnouncements;
        announcements = announcementController.listAnnouncements(includeGroups, includeWorkspaces, environment, timeFrame, currentUserEntity, onlyMine, onlyArchived);
    } else {
        WorkspaceEntity workspaceEntity = workspaceEntityController.findWorkspaceEntityById(workspaceEntityId);
        if (workspaceEntity == null) {
            return Response.status(Status.BAD_REQUEST).entity("Workspace entity with given ID not found").build();
        }
        if (!sessionController.hasWorkspacePermission(AnnouncerPermissions.LIST_WORKSPACE_ANNOUNCEMENTS, workspaceEntity)) {
            return Response.status(Status.FORBIDDEN).entity("You don't have the permission to list workspace announcements").build();
        }
        announcements = announcementController.listWorkspaceAnnouncements(Arrays.asList(workspaceEntity), environment, timeFrame, currentUserEntity, onlyMine, onlyArchived);
    }
    List<AnnouncementRESTModel> restModels = new ArrayList<>();
    for (Announcement announcement : announcements) {
        if (onlyEditable && !canEdit(announcement, currentUserEntity)) {
            continue;
        }
        List<AnnouncementUserGroup> announcementUserGroups = announcementController.listAnnouncementUserGroups(announcement);
        List<AnnouncementWorkspace> announcementWorkspaces = announcementController.listAnnouncementWorkspacesSortByUserFirst(announcement, currentUserEntity);
        AnnouncementRESTModel restModel = createRESTModel(announcement, announcementUserGroups, announcementWorkspaces);
        restModels.add(restModel);
    }
    return Response.ok(restModels).build();
}

Example 2 with AnnouncementUserGroup

use of fi.otavanopisto.muikku.plugins.announcer.model.AnnouncementUserGroup in project muikku by otavanopisto.

the class AnnouncerRESTService method updateAnnouncement.

@PUT
@Path("/announcements/{ID}")
@RESTPermit(handling = Handling.INLINE)
public Response updateAnnouncement(@PathParam("ID") Long announcementId, AnnouncementRESTModel restModel) {
    UserEntity userEntity = sessionController.getLoggedUserEntity();
    if (announcementId == null) {
        return Response.status(Status.BAD_REQUEST).build();
    }
    Announcement oldAnnouncement = announcementController.findById(announcementId);
    if (oldAnnouncement == null) {
        return Response.status(Status.NOT_FOUND).build();
    }
    // Check that the user has permission to update the old announcement
    if (!canEdit(oldAnnouncement, userEntity))
        return Response.status(Status.FORBIDDEN).entity("You don't have the permission to update this announcement.").build();
    List<Long> workspaceEntityIds = restModel.getWorkspaceEntityIds();
    if (workspaceEntityIds == null) {
        workspaceEntityIds = Collections.emptyList();
    }
    List<Long> userGroupEntityIds = restModel.getUserGroupEntityIds();
    if (userGroupEntityIds == null) {
        userGroupEntityIds = Collections.emptyList();
    }
    if (workspaceEntityIds.isEmpty() && !sessionController.hasEnvironmentPermission(AnnouncerPermissions.UPDATE_ANNOUNCEMENT)) {
        return Response.status(Status.FORBIDDEN).entity("You don't have the permission to update environment announcements").build();
    }
    for (Long workspaceEntityId : workspaceEntityIds) {
        WorkspaceEntity workspaceEntity = workspaceEntityController.findWorkspaceEntityById(workspaceEntityId);
        if (workspaceEntity == null) {
            return Response.status(Status.BAD_REQUEST).entity("Invalid workspaceEntityId").build();
        }
        if (!sessionController.hasWorkspacePermission(AnnouncerPermissions.UPDATE_WORKSPACE_ANNOUNCEMENT, workspaceEntity)) {
            return Response.status(Status.FORBIDDEN).entity("You don't have the permission to update workspace announcement").build();
        }
    }
    Announcement newAnnouncement = announcementController.updateAnnouncement(oldAnnouncement, restModel.getCaption(), restModel.getContent(), restModel.getStartDate(), restModel.getEndDate(), restModel.getPubliclyVisible(), restModel.isArchived());
    announcementController.clearAnnouncementTargetGroups(newAnnouncement);
    for (Long userGroupEntityId : userGroupEntityIds) {
        UserGroupEntity userGroupEntity = userGroupEntityController.findUserGroupEntityById(userGroupEntityId);
        if (userGroupEntity == null) {
            return Response.status(Status.BAD_REQUEST).entity("Invalid userGroupEntityId").build();
        }
        announcementController.addAnnouncementTargetGroup(newAnnouncement, userGroupEntity);
    }
    announcementController.clearAnnouncementWorkspaces(newAnnouncement);
    for (Long workspaceEntityId : workspaceEntityIds) {
        WorkspaceEntity workspaceEntity = workspaceEntityController.findWorkspaceEntityById(workspaceEntityId);
        if (workspaceEntity == null) {
            return Response.status(Status.BAD_REQUEST).entity("Invalid workspaceEntityId").build();
        }
        announcementController.addAnnouncementWorkspace(newAnnouncement, workspaceEntity);
    }
    List<AnnouncementUserGroup> announcementUserGroups = announcementController.listAnnouncementUserGroups(newAnnouncement);
    List<AnnouncementWorkspace> announcementWorkspaces = announcementController.listAnnouncementWorkspaces(newAnnouncement);
    return Response.ok(createRESTModel(newAnnouncement, announcementUserGroups, announcementWorkspaces)).build();
}

Example 3 with AnnouncementUserGroup

use of fi.otavanopisto.muikku.plugins.announcer.model.AnnouncementUserGroup in project muikku by otavanopisto.

the class AnnouncementDAO method listAnnouncements.

public List<Announcement> listAnnouncements(List<UserGroupEntity> userGroupEntities, List<WorkspaceEntity> workspaceEntities, AnnouncementEnvironmentRestriction environment, AnnouncementTimeFrame timeFrame, UserEntity announcementOwner, boolean archived) {
    EntityManager entityManager = getEntityManager();
    Date currentDate = onlyDateFields(new Date());
    CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
    CriteriaQuery<Announcement> criteria = criteriaBuilder.createQuery(Announcement.class);
    Root<Announcement> root = criteria.from(Announcement.class);
    criteria.select(root).distinct(true);
    List<Predicate> predicates = new ArrayList<Predicate>();
    predicates.add(criteriaBuilder.equal(root.get(Announcement_.archived), archived));
    switch(timeFrame) {
        case ALL:
            // No restrictions here
            break;
        case CURRENTANDUPCOMING:
            predicates.add(criteriaBuilder.greaterThanOrEqualTo(root.get(Announcement_.endDate), currentDate));
            break;
        case CURRENTANDEXPIRED:
            predicates.add(criteriaBuilder.lessThanOrEqualTo(root.get(Announcement_.startDate), currentDate));
            break;
        case CURRENT:
            predicates.add(criteriaBuilder.lessThanOrEqualTo(root.get(Announcement_.startDate), currentDate));
            predicates.add(criteriaBuilder.greaterThanOrEqualTo(root.get(Announcement_.endDate), currentDate));
            break;
        case UPCOMING:
            predicates.add(criteriaBuilder.greaterThan(root.get(Announcement_.startDate), currentDate));
            break;
        case EXPIRED:
            predicates.add(criteriaBuilder.lessThan(root.get(Announcement_.endDate), currentDate));
            break;
    }
    if (announcementOwner != null) {
        predicates.add(criteriaBuilder.equal(root.get(Announcement_.publisherUserEntityId), announcementOwner.getId()));
    }
    // Predicates for group visibility restrictions (workspace, usergroup or environment)
    List<Predicate> groupPredicates = new ArrayList<Predicate>();
    /**
     * Environment announcements:
     * - All announcements which are not tied to a workspace
     * - Publicly visible and/or group (when requested)
     */
    switch(environment) {
        case NONE:
            // No environment announcements added
            break;
        case PUBLIC:
            groupPredicates.add(criteriaBuilder.and(criteriaBuilder.not(criteriaBuilder.in(root).value(subqueryWorkspaceAnnouncements(criteriaBuilder, criteria))), criteriaBuilder.equal(root.get(Announcement_.publiclyVisible), Boolean.TRUE)));
            break;
        case PUBLICANDGROUP:
            groupPredicates.add(criteriaBuilder.not(criteriaBuilder.in(root).value(subqueryWorkspaceAnnouncements(criteriaBuilder, criteria))));
            break;
    }
    /**
     * Workspace announcements:
     * - All announcements tied to specified workspace(s)
     */
    if (CollectionUtils.isNotEmpty(workspaceEntities)) {
        List<Long> workspaceEntityIds = workspaceEntities.stream().map((WorkspaceEntity workspaceEntity) -> workspaceEntity.getId()).collect(Collectors.toList());
        Subquery<Announcement> subquery = criteria.subquery(Announcement.class);
        Root<AnnouncementWorkspace> announcementWorkspace = subquery.from(AnnouncementWorkspace.class);
        subquery.select(announcementWorkspace.get(AnnouncementWorkspace_.announcement));
        subquery.where(criteriaBuilder.and(criteriaBuilder.equal(announcementWorkspace.get(AnnouncementWorkspace_.archived), Boolean.FALSE), announcementWorkspace.get(AnnouncementWorkspace_.workspaceEntityId).in(workspaceEntityIds)));
        groupPredicates.add(root.in(subquery));
    }
    /**
     * User group announcements:
     * - Environment announcements that are tied to user group.
     */
    if (CollectionUtils.isNotEmpty(userGroupEntities)) {
        List<Long> userGroupEntityIds = userGroupEntities.stream().map((UserGroupEntity userGroupEntity) -> userGroupEntity.getId()).collect(Collectors.toList());
        Subquery<Announcement> subquery = criteria.subquery(Announcement.class);
        Root<AnnouncementUserGroup> announcementUserGroup = subquery.from(AnnouncementUserGroup.class);
        subquery.select(announcementUserGroup.get(AnnouncementUserGroup_.announcement));
        subquery.where(criteriaBuilder.and(criteriaBuilder.equal(announcementUserGroup.get(AnnouncementUserGroup_.archived), Boolean.FALSE), announcementUserGroup.get(AnnouncementUserGroup_.userGroupEntityId).in(userGroupEntityIds)));
        groupPredicates.add(root.in(subquery));
    }
    predicates.add(criteriaBuilder.or(groupPredicates.toArray(new Predicate[0])));
    criteria.where(criteriaBuilder.and(predicates.toArray(new Predicate[0])));
    criteria.orderBy(criteriaBuilder.desc(root.get(Announcement_.startDate)));
    return entityManager.createQuery(criteria).getResultList();
}

Example 4 with AnnouncementUserGroup

use of fi.otavanopisto.muikku.plugins.announcer.model.AnnouncementUserGroup in project muikku by otavanopisto.

the class AnnouncementUserGroupDAO method listByAnnouncementAndArchived.

public List<AnnouncementUserGroup> listByAnnouncementAndArchived(Announcement announcement, Boolean archived) {
    EntityManager entityManager = getEntityManager();
    CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
    CriteriaQuery<AnnouncementUserGroup> criteria = criteriaBuilder.createQuery(AnnouncementUserGroup.class);
    Root<AnnouncementUserGroup> root = criteria.from(AnnouncementUserGroup.class);
    criteria.select(root);
    criteria.where(criteriaBuilder.and(criteriaBuilder.equal(root.get(AnnouncementUserGroup_.announcement), announcement), criteriaBuilder.equal(root.get(AnnouncementUserGroup_.archived), archived)));
    return entityManager.createQuery(criteria).getResultList();
}

Example 5 with AnnouncementUserGroup

use of fi.otavanopisto.muikku.plugins.announcer.model.AnnouncementUserGroup in project muikku by otavanopisto.

the class AnnouncerRESTService method findAnnouncementById.

@GET
@Path("/announcements/{ID}")
@RESTPermit(AnnouncerPermissions.FIND_ANNOUNCEMENT)
public Response findAnnouncementById(@PathParam("ID") Long announcementId) {
    UserEntity userEntity = sessionController.getLoggedUserEntity();
    Announcement announcement = announcementController.findById(announcementId);
    if (announcement == null) {
        return Response.status(Status.NOT_FOUND).entity("Announcement not found").build();
    }
    List<AnnouncementUserGroup> announcementUserGroups = announcementController.listAnnouncementUserGroups(announcement);
    List<AnnouncementWorkspace> announcementWorkspaces = announcementController.listAnnouncementWorkspacesSortByUserFirst(announcement, userEntity);
    return Response.ok(createRESTModel(announcement, announcementUserGroups, announcementWorkspaces)).build();
}