Example usage for org.hibernate.type StringType INSTANCE

Introduction

In this page you can find the example usage for org.hibernate.type StringType INSTANCE.

Prototype

StringType INSTANCE

To view the source code for org.hibernate.type StringType INSTANCE.

Click Source Link

Usage

From source file:org.yamj.core.database.dao.ApiDao.java

License:Open Source License

/**
 * Get a list of the awards for a given video ID
 *
 * @param type/*  ww w. ja  va2  s  . c om*/
 * @param id
 * @return
 */
private List<ApiAwardDTO> getAwardsForId(MetaDataType type, Long id) {
    SqlScalars sqlScalars = new SqlScalars();
    sqlScalars
            .addToSql("SELECT DISTINCT a.event, a.category, a.sourcedb as source, c.year, c.won, c.nominated ");
    if (type == MetaDataType.SERIES) {
        sqlScalars.addToSql("FROM series_awards c ");
        sqlScalars.addToSql("JOIN award a ON c.award_id=a.id ");
        sqlScalars.addToSql("WHERE c.series_id=:id ");
    } else if (type == MetaDataType.SEASON) {
        sqlScalars.addToSql("FROM series_awards c ");
        sqlScalars.addToSql("JOIN season sea ON c.series_id=sea.series_id ");
        sqlScalars.addToSql("JOIN award a ON c.award_id=a.id ");
        sqlScalars.addToSql("WHERE sea.id=:id ");
    } else {
        // defaults to movie
        sqlScalars.addToSql("FROM videodata_awards c ");
        sqlScalars.addToSql("JOIN award a ON c.award_id=a.id ");
        sqlScalars.addToSql("WHERE c.videodata_id=:id ");
    }
    sqlScalars.addToSql("ORDER BY year, event");

    sqlScalars.addScalar("event", StringType.INSTANCE);
    sqlScalars.addScalar("category", StringType.INSTANCE);
    sqlScalars.addScalar("source", StringType.INSTANCE);
    sqlScalars.addScalar("year", IntegerType.INSTANCE);
    sqlScalars.addScalar("won", BooleanType.INSTANCE);
    sqlScalars.addScalar("nominated", BooleanType.INSTANCE);

    sqlScalars.addParameter(ID, id);

    return executeQueryWithTransform(ApiAwardDTO.class, sqlScalars, null);
}

---

From source file:org.yamj.core.database.dao.ApiDao.java

License:Open Source License

/**
 * Get a list of the ratings for a given video ID
 *
 * @param type/*w w  w .j a  va2 s  .  c om*/
 * @param id
 * @return
 */
private List<ApiRatingDTO> getRatingsForId(MetaDataType type, Long id) {
    SqlScalars sqlScalars = new SqlScalars();
    sqlScalars.addToSql("SELECT r1.rating, r1.sourcedb AS source, 2 AS sorting ");
    if (type == MetaDataType.SERIES) {
        sqlScalars.addToSql("FROM series_ratings r1 ");
        sqlScalars.addToSql("WHERE r1.series_id=:id ");
    } else if (type == MetaDataType.SEASON) {
        sqlScalars.addToSql("FROM series_ratings r1, season sea ");
        sqlScalars.addToSql("WHERE sea.id=:id ");
        sqlScalars.addToSql("AND sea.series_id=r1.series_id ");
    } else {
        // defaults to movie
        sqlScalars.addToSql("FROM videodata_ratings r1 ");
        sqlScalars.addToSql("WHERE r1.videodata_id=:id ");
    }
    sqlScalars.addToSql("UNION ");
    // combined rating
    sqlScalars.addToSql("SELECT round(grouped.average) AS rating, 'combined' AS source, 1 AS sorting FROM ");
    sqlScalars.addToSql("(SELECT avg(r2.rating) as average ");
    if (type == MetaDataType.SERIES) {
        sqlScalars.addToSql("FROM series_ratings r2 ");
        sqlScalars.addToSql("WHERE r2.series_id=:id ");
    } else if (type == MetaDataType.SEASON) {
        sqlScalars.addToSql("FROM series_ratings r2, season sea ");
        sqlScalars.addToSql("WHERE sea.id=:id ");
        sqlScalars.addToSql("AND sea.series_id=r2.series_id ");
    } else {
        // defaults to movie
        sqlScalars.addToSql("FROM videodata_ratings r2 ");
        sqlScalars.addToSql("WHERE r2.videodata_id=:id ");
    }
    sqlScalars.addToSql(") AS grouped ");
    sqlScalars.addToSql("WHERE grouped.average is not null ");
    sqlScalars.addToSql("ORDER BY sorting, source ");

    sqlScalars.addScalar("source", StringType.INSTANCE);
    sqlScalars.addScalar("rating", IntegerType.INSTANCE);
    sqlScalars.addParameter(ID, id);

    return executeQueryWithTransform(ApiRatingDTO.class, sqlScalars, null);
}

---

From source file:org.yamj.core.database.dao.ApiDao.java

License:Open Source License

/**
 * Get a list of the cast for a given video ID
 *
 * @param type//w  w  w.jav a 2  s.co m
 * @param id
 * @return
 */
private List<ApiPersonDTO> getCastForId(MetaDataType type, Long id, List<DataItem> dataItems,
        Set<String> jobs) {
    SqlScalars sqlScalars = new SqlScalars();
    sqlScalars.addToSql("SELECT DISTINCT p.id,");
    if (dataItems.contains(DataItem.BIOGRAPHY)) {
        sqlScalars.addToSql("p.biography,");
        sqlScalars.addScalar("biography", StringType.INSTANCE);
    }
    sqlScalars.addToSql("p.name,");
    sqlScalars.addToSql("p.first_name AS firstName,");
    sqlScalars.addToSql("p.last_name AS lastName,");
    sqlScalars.addToSql("p.birth_day AS birthDay,");
    sqlScalars.addToSql("p.birth_place AS birthPlace,");
    sqlScalars.addToSql("p.birth_name AS birthName,");
    sqlScalars.addToSql("p.death_day AS deathDay,");
    sqlScalars.addToSql("p.death_place AS deathPlace,");
    sqlScalars.addToSql("c.role as role,");
    sqlScalars.addToSql("c.job as jobTypeAsString ");
    sqlScalars.addToSql("FROM person p ");

    if (type == MetaDataType.SERIES) {
        sqlScalars.addToSql("JOIN cast_crew c ON p.id=c.person_id ");
        sqlScalars.addToSql("JOIN season sea ON sea.series_id=:id ");
        sqlScalars.addToSql("JOIN videodata vd ON vd.id=c.videodata_id and vd.season_id=sea.id ");
    } else if (type == MetaDataType.SEASON) {
        sqlScalars.addToSql("JOIN cast_crew c ON p.id=c.person_id ");
        sqlScalars.addToSql("JOIN videodata vd ON vd.id=c.videodata_id and vd.season_id=:id ");
    } else {
        // defaults to movie/episode
        sqlScalars.addToSql("JOIN cast_crew c ON p.id=c.person_id and c.videodata_id=:id ");
    }

    if (jobs != null) {
        sqlScalars.addToSql("WHERE c.job in (:jobs) ");
        sqlScalars.addParameter("jobs", jobs);
    }
    sqlScalars.addToSql("ORDER BY c.ordering");

    sqlScalars.addScalar(ID, LongType.INSTANCE);
    sqlScalars.addScalar("name", StringType.INSTANCE);
    sqlScalars.addScalar("firstName", StringType.INSTANCE);
    sqlScalars.addScalar("lastName", StringType.INSTANCE);
    sqlScalars.addScalar("birthDay", DateType.INSTANCE);
    sqlScalars.addScalar("birthPlace", StringType.INSTANCE);
    sqlScalars.addScalar("birthName", StringType.INSTANCE);
    sqlScalars.addScalar("deathDay", DateType.INSTANCE);
    sqlScalars.addScalar("deathPlace", StringType.INSTANCE);
    sqlScalars.addScalar("role", StringType.INSTANCE);
    sqlScalars.addScalar("jobTypeAsString", StringType.INSTANCE);
    sqlScalars.addParameter(ID, id);

    return executeQueryWithTransform(ApiPersonDTO.class, sqlScalars, null);
}

---

From source file:org.yamj.core.database.dao.ApiDao.java

License:Open Source License

/**
 * Get a select list of artwork available for a video ID
 *
 * @param type/*from   w w w . j a  va2 s  . co  m*/
 * @param id
 * @param artworkRequired
 * @return
 */
public Map<Long, List<ApiArtworkDTO>> getArtworkForId(MetaDataType type, Object id,
        Set<String> artworkRequired) {
    LOG.trace("Artwork required for {} ID {} is {}", type, id, artworkRequired);

    StringBuilder sbSQL = new StringBuilder();
    sbSQL.append("SELECT '").append(type.toString()).append("' AS sourceString,");
    sbSQL.append(" v.id AS sourceId, a.id AS artworkId, al.id AS locatedId, ag.id AS generatedId,");
    sbSQL.append(
            " a.artwork_type AS artworkTypeString, ag.cache_dir AS cacheDir, ag.cache_filename AS cacheFilename ");
    if (type == MetaDataType.MOVIE) {
        sbSQL.append("FROM videodata v ");
    } else if (type == MetaDataType.SERIES) {
        sbSQL.append("FROM series v ");
    } else if (type == MetaDataType.SEASON) {
        sbSQL.append("FROM season v ");
    } else if (type == MetaDataType.PERSON) {
        sbSQL.append("FROM person v");
    } else if (type == MetaDataType.BOXSET) {
        sbSQL.append("FROM boxed_set v");
    }
    sbSQL.append(", artwork a"); // Artwork must be last for the LEFT JOIN
    sbSQL.append(SQL_LEFT_JOIN_ARTWORK_LOCATED);
    sbSQL.append(SQL_LEFT_JOIN_ARTWORK_GENERATED);
    if (type == MetaDataType.MOVIE) {
        sbSQL.append(" WHERE v.id=a.videodata_id");
        sbSQL.append(" AND v.episode<0");
    } else if (type == MetaDataType.SERIES) {
        sbSQL.append(" WHERE v.id=a.series_id");
    } else if (type == MetaDataType.SEASON) {
        sbSQL.append(" WHERE v.id=a.season_id");
    } else if (type == MetaDataType.PERSON) {
        sbSQL.append(" WHERE v.id=a.person_id");
    } else if (type == MetaDataType.BOXSET) {
        sbSQL.append(" WHERE v.id=a.boxedset_id");
    }
    sbSQL.append(" AND al.id is not null");
    sbSQL.append(" AND v.id IN (:id)");
    sbSQL.append(SQL_ARTWORK_TYPE_IN_ARTWORKLIST);

    SqlScalars sqlScalars = new SqlScalars(sbSQL);
    LOG.info("Artwork SQL: {}", sqlScalars.getSql());

    sqlScalars.addScalar("sourceString", StringType.INSTANCE);
    sqlScalars.addScalar("sourceId", LongType.INSTANCE);
    sqlScalars.addScalar("artworkId", LongType.INSTANCE);
    sqlScalars.addScalar("locatedId", LongType.INSTANCE);
    sqlScalars.addScalar("generatedId", LongType.INSTANCE);
    sqlScalars.addScalar("artworkTypeString", StringType.INSTANCE);
    sqlScalars.addScalar(CACHE_DIR, StringType.INSTANCE);
    sqlScalars.addScalar(CACHE_FILENAME, StringType.INSTANCE);

    sqlScalars.addParameter(ID, id);
    sqlScalars.addParameter("artworklist", artworkRequired);

    List<ApiArtworkDTO> results = executeQueryWithTransform(ApiArtworkDTO.class, sqlScalars, null);
    return generateIdMapList(results);
}

---

From source file:org.yamj.core.database.dao.ApiDao.java

License:Open Source License

public void getSeriesInfo(ApiWrapperList<ApiSeriesInfoDTO> wrapper) {
    OptionsIdArtwork options = (OptionsIdArtwork) wrapper.getOptions();
    Long id = options.getId();//ww w.j  ava2 s .  c  o m
    LOG.info("Getting series information for series ID {}", id);

    SqlScalars sqlScalars = new SqlScalars();
    sqlScalars.addToSql(
            "SELECT s.id AS seriesId, s.title, s.title_original AS originalTitle, s.start_year AS seriesYear, ");
    if (options.hasDataItem(DataItem.PLOT)) {
        sqlScalars.addToSql("s.plot, ");
        sqlScalars.addScalar("plot", StringType.INSTANCE);
    }
    if (options.hasDataItem(DataItem.OUTLINE)) {
        sqlScalars.addToSql("s.outline, ");
        sqlScalars.addScalar("outline", StringType.INSTANCE);
    }
    sqlScalars.addToSql(
            "(SELECT min(vid.watched_nfo or vid.watched_file or vid.watched_api) from videodata vid,season sea where vid.season_id=sea.id and sea.series_id=s.id) as watched ");
    sqlScalars.addToSql("FROM series s");
    sqlScalars.addToSql("WHERE id=:id");
    sqlScalars.addToSql("ORDER BY id");
    sqlScalars.addParameter(ID, id);

    sqlScalars.addScalar(SERIES_ID, LongType.INSTANCE);
    sqlScalars.addScalar(TITLE, StringType.INSTANCE);
    sqlScalars.addScalar(ORIGINAL_TITLE, StringType.INSTANCE);
    sqlScalars.addScalar(SERIES_YEAR, IntegerType.INSTANCE);
    sqlScalars.addScalar(WATCHED, BooleanType.INSTANCE);

    List<ApiSeriesInfoDTO> seriesResults = executeQueryWithTransform(ApiSeriesInfoDTO.class, sqlScalars,
            wrapper);
    LOG.debug("Found {} series for ID {}", seriesResults.size(), id);

    for (ApiSeriesInfoDTO series : seriesResults) {
        if (options.hasDataItem(DataItem.GENRE)) {
            series.setGenres(getGenresForId(MetaDataType.SERIES, id));
        }

        if (options.hasDataItem(DataItem.STUDIO)) {
            series.setStudios(getStudiosForId(MetaDataType.SERIES, id));
        }

        if (options.hasDataItem(DataItem.COUNTRY)) {
            series.setCountries(getCountriesForId(MetaDataType.SERIES, id));
        }

        if (options.hasDataItem(DataItem.CERTIFICATION)) {
            series.setCertifications(getCertificationsForId(MetaDataType.SERIES, id));
        }

        if (options.hasDataItem(DataItem.RATING)) {
            series.setRatings(getRatingsForId(MetaDataType.SERIES, id));
        }

        if (options.hasDataItem(DataItem.AWARD)) {
            series.setAwards(getAwardsForId(MetaDataType.SERIES, id));
        }

        if (options.hasDataItem(DataItem.ARTWORK)) {
            Map<Long, List<ApiArtworkDTO>> artworkList = getArtworkForId(MetaDataType.SERIES, id,
                    options.getArtworkTypes());
            if (artworkList == null || !artworkList.containsKey(id)
                    || CollectionUtils.isEmpty(artworkList.get(id))) {
                LOG.debug("No artwork found for seriesId {}", id);
            } else {
                for (ApiArtworkDTO artwork : artworkList.get(id)) {
                    series.addArtwork(artwork);
                }
            }
        }
        series.setSeasonList(getSeasonInfo(options));
    }
    wrapper.setResults(seriesResults);
}

---

From source file:org.yamj.core.database.dao.ApiDao.java

License:Open Source License

private List<ApiSeasonInfoDTO> getSeasonInfo(OptionsIdArtwork options) {
    Long id = options.getId();/* ww w  .j a  va  2s.co  m*/

    LOG.debug("Getting season information for series ID {}", id);
    SqlScalars sqlScalars = new SqlScalars();
    sqlScalars.addToSql(
            "SELECT s.series_id AS seriesId, s.id AS seasonId, s.season, s.title, s.title_original AS originalTitle,");
    if (options.hasDataItem(DataItem.PLOT)) {
        sqlScalars.addToSql("s.plot, ");
        sqlScalars.addScalar("plot", StringType.INSTANCE);
    }
    if (options.hasDataItem(DataItem.OUTLINE)) {
        sqlScalars.addToSql("s.outline, ");
        sqlScalars.addScalar("outline", StringType.INSTANCE);
    }
    sqlScalars.addToSql(
            "(SELECT min(vid.watched_nfo or vid.watched_file or vid.watched_api) from videodata vid where vid.season_id=s.id) as watched ");
    sqlScalars.addToSql("FROM season s");
    sqlScalars.addToSql("WHERE series_id=:id");
    sqlScalars.addToSql("ORDER BY series_id, season");
    sqlScalars.addParameter(ID, id);

    sqlScalars.addScalar(SERIES_ID, LongType.INSTANCE);
    sqlScalars.addScalar(SEASON_ID, LongType.INSTANCE);
    sqlScalars.addScalar(SEASON, IntegerType.INSTANCE);
    sqlScalars.addScalar(TITLE, StringType.INSTANCE);
    sqlScalars.addScalar(ORIGINAL_TITLE, StringType.INSTANCE);
    sqlScalars.addScalar(WATCHED, BooleanType.INSTANCE);

    List<ApiSeasonInfoDTO> seasonResults = executeQueryWithTransform(ApiSeasonInfoDTO.class, sqlScalars, null);
    LOG.debug("Found {} seasons for series ID {}", seasonResults.size(), id);

    if (options.hasDataItem(DataItem.ARTWORK)) {
        for (ApiSeasonInfoDTO season : seasonResults) {
            Map<Long, List<ApiArtworkDTO>> artworkList = getArtworkForId(MetaDataType.SEASON,
                    season.getSeasonId(), options.getArtworkTypes());
            if (artworkList == null || !artworkList.containsKey(season.getSeasonId())
                    || CollectionUtils.isEmpty(artworkList.get(season.getSeasonId()))) {
                LOG.debug("No artwork found for series ID {} and season {}", id, season.getSeason());
            } else {
                for (ApiArtworkDTO artwork : artworkList.get(season.getSeasonId())) {
                    season.addArtwork(artwork);
                }
            }
        }
    }

    return seasonResults;
}

---

From source file:org.yamj.core.database.dao.ApiDao.java

License:Open Source License

/**
 * Get a single Count and Timestamp//from  w  w  w.j av  a2s.c  o  m
 *
 * @param type
 * @param tablename
 * @param clause
 * @return
 */
public CountTimestamp getCountTimestamp(MetaDataType type, String tablename, String clause) {
    if (StringUtils.isBlank(tablename)) {
        return null;
    }

    StringBuilder sql = new StringBuilder("SELECT '").append(type).append("' as typeString, ");
    sql.append("count(*) as count, ");
    sql.append("MAX(create_timestamp) as createTimestamp, ");
    sql.append("MAX(update_timestamp) as updateTimestamp, ");
    sql.append("MAX(id) as lastId ");
    sql.append("FROM ").append(tablename);
    if (StringUtils.isNotBlank(clause)) {
        sql.append(" WHERE ").append(clause);
    }

    SqlScalars sqlScalars = new SqlScalars(sql);

    sqlScalars.addScalar("typeString", StringType.INSTANCE);
    sqlScalars.addScalar("count", LongType.INSTANCE);
    sqlScalars.addScalar("createTimestamp", TimestampType.INSTANCE);
    sqlScalars.addScalar("updateTimestamp", TimestampType.INSTANCE);
    sqlScalars.addScalar("lastId", LongType.INSTANCE);

    List<CountTimestamp> results = executeQueryWithTransform(CountTimestamp.class, sqlScalars, null);
    if (CollectionUtils.isEmpty(results)) {
        return new CountTimestamp(type);
    }

    return results.get(0);
}

---

From source file:org.yamj.core.database.dao.ApiDao.java

License:Open Source License

/**
 * Get a count of the jobs along with a count
 *
 * @param requiredJobs//  w w w.j av a 2 s  . c o  m
 * @return
 */
public List<CountGeneric> getJobCount(List<String> requiredJobs) {
    LOG.info("getJobCount: Required Jobs: {}", (requiredJobs == null ? "all" : requiredJobs));
    SqlScalars sqlScalars = new SqlScalars();

    sqlScalars.addToSql("SELECT job AS item, COUNT(*) AS count");
    sqlScalars.addToSql("FROM cast_crew");
    if (CollectionUtils.isNotEmpty(requiredJobs)) {
        sqlScalars.addToSql("WHERE job IN (:joblist)");
        sqlScalars.addParameter("joblist", requiredJobs);
    }
    sqlScalars.addToSql("GROUP BY job");

    sqlScalars.addScalar("item", StringType.INSTANCE);
    sqlScalars.addScalar("count", LongType.INSTANCE);

    return executeQueryWithTransform(CountGeneric.class, sqlScalars, null);
}

---

From source file:org.yamj.core.database.dao.ApiDao.java

License:Open Source License

public void statSeriesCount() {
    SqlScalars sqlScalars = new SqlScalars();
    sqlScalars.addToSql("SELECT s.id AS seriesId, title, start_year AS seriesYear");
    sqlScalars.addToSql("FROM series s");

    sqlScalars.addScalar(SERIES_ID, LongType.INSTANCE);
    sqlScalars.addScalar(TITLE, StringType.INSTANCE);
    sqlScalars.addScalar(SERIES_YEAR, IntegerType.INSTANCE);

    // Get the results
    List<ApiSeriesInfoDTO> seriesResults = executeQueryWithTransform(ApiSeriesInfoDTO.class, sqlScalars, null);
    if (!seriesResults.isEmpty()) {
        // Set the default oldest and newest
        ApiSeriesInfoDTO oldest = seriesResults.get(0);
        ApiSeriesInfoDTO newest = seriesResults.get(0);

        for (ApiSeriesInfoDTO series : seriesResults) {
            if (series.getYear() > newest.getYear()) {
                newest = series;// ww  w .ja  v a  2 s  .c o  m
            }
            if (series.getYear() < oldest.getYear()) {
                oldest = series;
            }
        }
    }

    // Process the results into statistics
}

---

From source file:org.yamj.core.database.dao.ApiDao.java

License:Open Source License

/**
 * Get list of external IDs for a metadata object.
 * //from w w w . ja va2  s . c o m
 * @param type the metadata type
 * @param id the id of the metadata object
 * @return
 */
private List<ApiExternalIdDTO> getExternalIdsForId(MetaDataType type, Long id) {
    SqlScalars sqlScalars = new SqlScalars();

    if (type == MetaDataType.SERIES) {
        sqlScalars.addToSql(
                "SELECT ids.series_id AS id, ids.sourcedb_id AS externalId, ids.sourcedb AS sourcedb,");
        sqlScalars.addToSql(
                "concat(coalesce(ser.skip_scan_api,''),';',coalesce(ser.skip_scan_nfo,'')) like concat('%',ids.sourcedb,'%') as skipped");
        sqlScalars.addToSql("FROM series ser, series_ids ids");
        sqlScalars.addToSql("WHERE ser.id=:id AND ids.series_id=ser.id");
    } else if (type == MetaDataType.SEASON) {
        sqlScalars.addToSql(
                "SELECT ids.season_id AS id, ids.sourcedb_id AS externalId, ids.sourcedb AS sourcedb, 0 as skipped");
        sqlScalars.addToSql("FROM season_ids ids");
        sqlScalars.addToSql("WHERE ids.season_id=:id");
    } else if (type == MetaDataType.PERSON) {
        sqlScalars.addToSql(
                "SELECT ids.person_id AS id, ids.sourcedb_id AS externalId, ids.sourcedb AS sourcedb,");
        sqlScalars.addToSql("coalesce(p.skip_scan_api,'') like concat('%',ids.sourcedb,'%') as skipped");
        sqlScalars.addToSql("FROM person p, person_ids ids");
        sqlScalars.addToSql("WHERE p.id=:id AND ids.person_id=p.id");
    } else {
        sqlScalars.addToSql(
                "SELECT ids.videodata_id AS id, ids.sourcedb_id AS externalId, ids.sourcedb AS sourcedb,");
        sqlScalars.addToSql(
                "concat(coalesce(vd.skip_scan_api,''),';',coalesce(vd.skip_scan_nfo,'')) like concat('%',ids.sourcedb,'%') as skipped");
        sqlScalars.addToSql("FROM videodata vd, videodata_ids ids");
        sqlScalars.addToSql("WHERE vd.id=:id AND ids.videodata_id=vd.id");
    }

    sqlScalars.addParameter(ID, id);

    sqlScalars.addScalar(ID, LongType.INSTANCE);
    sqlScalars.addScalar("externalId", StringType.INSTANCE);
    sqlScalars.addScalar("sourcedb", StringType.INSTANCE);
    sqlScalars.addScalar("skipped", BooleanType.INSTANCE);

    return executeQueryWithTransform(ApiExternalIdDTO.class, sqlScalars, null);
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• »