Example usage for org.hibernate.type BooleanType INSTANCE

List of usage examples for org.hibernate.type BooleanType INSTANCE

  1. HOME
  2. Java
  3. org.hibernate
  4. org.hibernate.type.*
  5. BooleanType
  6. INSTANCE

Introduction

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

Prototype

BooleanType INSTANCE

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

Click Source Link

Usage

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

License:Open Source License

/**
 * Generate the query and load the results into the wrapper
 *
 * @param wrapper/* w  w  w. ja  v  a  2  s .  c  o m*/
 */
@SuppressWarnings({ "unchecked", "rawtypes" })
public void getVideoList(ApiWrapperList<ApiVideoDTO> wrapper) {
    OptionsIndexVideo options = (OptionsIndexVideo) wrapper.getOptions();
    IndexParams params = new IndexParams(options);

    SqlScalars sqlScalars = new SqlScalars(generateSqlForVideoList(params));
    sqlScalars.addScalar(ID, LongType.INSTANCE);
    sqlScalars.addScalar("videoTypeString", StringType.INSTANCE);
    sqlScalars.addScalar(TITLE, StringType.INSTANCE);
    sqlScalars.addScalar(ORIGINAL_TITLE, StringType.INSTANCE);
    sqlScalars.addScalar(VIDEO_YEAR, IntegerType.INSTANCE);
    sqlScalars.addScalar(SERIES_ID, LongType.INSTANCE);
    sqlScalars.addScalar(SEASON_ID, LongType.INSTANCE);
    sqlScalars.addScalar(SEASON, LongType.INSTANCE);
    sqlScalars.addScalar(WATCHED, BooleanType.INSTANCE);

    if (params.includeNewest() || params.excludeNewest()) {
        sqlScalars.addScalar("newest", TimestampType.INSTANCE);
    }

    // add Scalars for additional data item columns
    DataItemTools.addDataItemScalars(sqlScalars, params.getDataItems());
    // add additional parameters
    params.addScalarParameters(sqlScalars);

    DataItemTools.addDataItemScalars(sqlScalars, params.getDataItems());

    List<ApiVideoDTO> queryResults = executeQueryWithTransform(ApiVideoDTO.class, sqlScalars, wrapper);
    wrapper.setResults(queryResults);

    if (CollectionUtils.isNotEmpty(queryResults)) {

        if (params.hasDataItem(DataItem.GENRE)) {
            LOG.trace("Adding genres to index videos");
            for (ApiVideoDTO video : queryResults) {
                video.setGenres(this.getGenresForId(video.getVideoType(), video.getId()));
            }
        }

        if (params.hasDataItem(DataItem.STUDIO)) {
            LOG.trace("Adding studios to index videos");
            for (ApiVideoDTO video : queryResults) {
                video.setStudios(this.getStudiosForId(video.getVideoType(), video.getId()));
            }
        }

        if (params.hasDataItem(DataItem.COUNTRY)) {
            LOG.trace("Adding countries to index videos");
            for (ApiVideoDTO video : queryResults) {
                video.setCountries(this.getCountriesForId(video.getVideoType(), video.getId()));
            }
        }

        if (params.hasDataItem(DataItem.CERTIFICATION)) {
            LOG.trace("Adding certifications to index videos");
            for (ApiVideoDTO video : queryResults) {
                video.setCertifications(this.getCertificationsForId(video.getVideoType(), video.getId()));
            }
        }

        if (params.hasDataItem(DataItem.RATING)) {
            LOG.trace("Adding ratings to index videos");
            for (ApiVideoDTO video : queryResults) {
                video.setRatings(this.getRatingsForId(video.getVideoType(), video.getId()));
            }
        }

        if (params.hasDataItem(DataItem.AWARD)) {
            LOG.trace("Adding awards to index videos");
            for (ApiVideoDTO video : queryResults) {
                video.setAwards(this.getAwardsForId(video.getVideoType(), video.getId()));
            }
        }

        if (params.hasDataItem(DataItem.EXTERNALID)) {
            LOG.trace("Adding external IDs to index videos");
            for (ApiVideoDTO video : queryResults) {
                video.setExternalIds(this.getExternalIdsForId(video.getVideoType(), video.getId()));
            }
        }

        if (params.hasDataItem(DataItem.BOXSET)) {
            LOG.trace("Adding boxed sets to index videos");
            for (ApiVideoDTO video : queryResults) {
                video.setBoxedSets(this.getBoxedSetsForId(video.getVideoType(), video.getId()));
            }
        }

        if (params.hasDataItem(DataItem.TRAILER)) {
            LOG.trace("Adding trailers to index videos");
            for (ApiVideoDTO video : queryResults) {
                video.setTrailers(this.getTrailersForId(video.getVideoType(), video.getId()));
            }
        }

        if (CollectionUtils.isNotEmpty(options.getArtworkTypes())) {
            // Create and populate the ID list
            Map<MetaDataType, List<Long>> ids = new EnumMap<>(MetaDataType.class);
            for (MetaDataType mdt : MetaDataType.values()) {
                ids.put(mdt, new ArrayList());
            }

            Map<String, ApiVideoDTO> results = new HashMap<>();

            for (ApiVideoDTO video : queryResults) {
                // Add the item to the map for further processing
                results.put(ApiArtworkDTO.makeKey(video), video);
                // Add the ID to the list
                ids.get(video.getVideoType()).add(video.getId());
            }

            boolean foundArtworkIds = Boolean.FALSE; // Check to see that we have artwork to find
            // Remove any blank entries
            for (MetaDataType mdt : MetaDataType.values()) {
                if (CollectionUtils.isEmpty(ids.get(mdt))) {
                    ids.remove(mdt);
                } else {
                    // We've found an artwork, so we can continue
                    foundArtworkIds = Boolean.TRUE;
                }
            }

            if (foundArtworkIds) {
                LOG.trace("Found artwork to process, IDs: {}", ids);
                addArtworks(ids, results, options);
            } else {
                LOG.trace("No artwork found to process, skipping.");
            }
        } else {
            LOG.trace("Artwork not required, skipping.");
        }
    } else {
        LOG.debug("No results found to process.");
    }
}

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

License:Open Source License

public void getEpisodeList(ApiWrapperList<ApiEpisodeDTO> wrapper) {
    OptionsEpisode options = (OptionsEpisode) wrapper.getOptions();
    SqlScalars sqlScalars = new SqlScalars();

    sqlScalars.addToSql("SELECT ser.id AS seriesId, sea.id AS seasonId, sea.season, vid.episode, ");
    sqlScalars.addToSql(/*from   ww  w  . j  av  a  2s  .c o m*/
            "vid.id, vid.title, vid.title_original as originalTitle, vid.release_date as firstAired, ");
    sqlScalars.addToSql("(vid.watched_nfo or vid.watched_file or vid.watched_api) as watched, ");
    if (options.hasDataItem(DataItem.PLOT)) {
        sqlScalars.addToSql("vid.plot, ");
        sqlScalars.addScalar("plot", StringType.INSTANCE);
    }
    if (options.hasDataItem(DataItem.OUTLINE)) {
        sqlScalars.addToSql("vid.outline, ");
        sqlScalars.addScalar("outline", StringType.INSTANCE);
    }
    sqlScalars.addToSql("ag.cache_filename AS cacheFilename, ag.cache_dir AS cacheDir");
    sqlScalars.addToSql("FROM season sea, series ser, videodata vid, artwork a");
    sqlScalars.addToSql(SQL_LEFT_JOIN_ARTWORK_LOCATED);
    sqlScalars.addToSql(SQL_LEFT_JOIN_ARTWORK_GENERATED);
    sqlScalars.addToSql("WHERE sea.series_id=ser.id");
    sqlScalars.addToSql("AND vid.season_id=sea.id");
    sqlScalars.addToSql("AND a.videodata_id=vid.id");

    if (options.getSeriesid() > 0L) {
        sqlScalars.addToSql("AND ser.id=:seriesid");
        sqlScalars.addParameter("seriesid", options.getSeriesid());
        if (options.getSeason() > 0L) {
            sqlScalars.addToSql("AND sea.season=:season");
            sqlScalars.addParameter(SEASON, options.getSeason());
        }
    }

    if (options.getSeasonid() > 0L) {
        sqlScalars.addToSql("AND sea.id=:seasonid");
        sqlScalars.addParameter("seasonid", options.getSeasonid());
    }

    if (options.getWatched() != null && options.getWatched()) {
        sqlScalars.addToSql(" AND (vid.watched_nfo=1 or vid.watched_file=1 or vid.watched_api=1)");
    } else if (options.getWatched() != null && !options.getWatched()) {
        sqlScalars.addToSql(" AND vid.watched_nfo=0 AND vid.watched_file=0 AND vid.watched_api=0");
    }

    sqlScalars.addToSql(" ORDER BY seriesId, season, episode");
    LOG.debug("getEpisodeList SQL: {}", sqlScalars.getSql());

    sqlScalars.addScalar(ID, LongType.INSTANCE);
    sqlScalars.addScalar(SERIES_ID, LongType.INSTANCE);
    sqlScalars.addScalar(SEASON_ID, LongType.INSTANCE);
    sqlScalars.addScalar(SEASON, LongType.INSTANCE);
    sqlScalars.addScalar(EPISODE, LongType.INSTANCE);
    sqlScalars.addScalar(TITLE, StringType.INSTANCE);
    sqlScalars.addScalar(ORIGINAL_TITLE, StringType.INSTANCE);
    sqlScalars.addScalar(CACHE_FILENAME, StringType.INSTANCE);
    sqlScalars.addScalar(CACHE_DIR, StringType.INSTANCE);
    sqlScalars.addScalar("firstAired", DateType.INSTANCE);
    sqlScalars.addScalar(WATCHED, BooleanType.INSTANCE);

    List<ApiEpisodeDTO> results = executeQueryWithTransform(ApiEpisodeDTO.class, sqlScalars, wrapper);
    if (CollectionUtils.isNotEmpty(results)) {
        if (options.hasDataItem(DataItem.FILES)) {
            for (ApiEpisodeDTO episode : results) {
                episode.setFiles(getFilesForId(MetaDataType.EPISODE, episode.getId()));
            }
        }
        if (options.hasDataItem(DataItem.GENRE)) {
            // use series genres
            Map<Long, List<ApiGenreDTO>> map = new HashMap<>();
            for (ApiEpisodeDTO episode : results) {
                List<ApiGenreDTO> genres = map.get(episode.getSeriesId());
                if (genres == null) {
                    genres = getGenresForId(MetaDataType.SERIES, episode.getSeriesId());
                    map.put(episode.getSeriesId(), genres);
                }
                episode.setGenres(genres);
            }
        }
        if (options.hasDataItem(DataItem.COUNTRY)) {
            // use series countries
            Map<Long, List<ApiCountryDTO>> map = new HashMap<>();
            for (ApiEpisodeDTO episode : results) {
                List<ApiCountryDTO> countries = map.get(episode.getSeriesId());
                if (countries == null) {
                    countries = getCountriesForId(MetaDataType.SERIES, episode.getSeriesId());
                    map.put(episode.getSeriesId(), countries);
                }
                episode.setCountries(countries);
            }
        }
        if (options.hasDataItem(DataItem.STUDIO)) {
            // use series studios
            Map<Long, List<Studio>> map = new HashMap<>();
            for (ApiEpisodeDTO episode : results) {
                List<Studio> studios = map.get(episode.getSeriesId());
                if (studios == null) {
                    studios = getStudiosForId(MetaDataType.SERIES, episode.getSeriesId());
                    map.put(episode.getSeriesId(), studios);
                }
                episode.setStudios(studios);
            }
        }
        if (options.hasDataItem(DataItem.CERTIFICATION)) {
            // use series certifications
            Map<Long, List<ApiCertificationDTO>> map = new HashMap<>();
            for (ApiEpisodeDTO episode : results) {
                List<ApiCertificationDTO> certifications = map.get(episode.getSeriesId());
                if (certifications == null) {
                    certifications = getCertificationsForId(MetaDataType.SERIES, episode.getSeriesId());
                    map.put(episode.getSeriesId(), certifications);
                }
                episode.setCertifications(certifications);
            }
        }
        if (options.hasDataItem(DataItem.AWARD)) {
            // use series awards
            Map<Long, List<ApiAwardDTO>> map = new HashMap<>();
            for (ApiEpisodeDTO episode : results) {
                List<ApiAwardDTO> awards = map.get(episode.getSeriesId());
                if (awards == null) {
                    awards = getAwardsForId(MetaDataType.SERIES, episode.getSeriesId());
                    map.put(episode.getSeriesId(), awards);
                }
                episode.setAwards(awards);
            }
        }
        if (options.hasDataItem(DataItem.RATING)) {
            // use episode certifications
            for (ApiEpisodeDTO episode : results) {
                episode.setRatings(getRatingsForId(MetaDataType.EPISODE, episode.getId()));
            }
        }

        if (MapUtils.isNotEmpty(options.splitJobs())) {
            Set<String> jobs = options.getJobTypesAsSet();

            for (ApiEpisodeDTO episode : results) {
                List<ApiPersonDTO> cast = getCastForId(MetaDataType.EPISODE, episode.getId(),
                        options.splitDataItems(), jobs);

                // just add given amount for jobs to cast
                Map<JobType, Integer> jobMap = new HashMap<>(options.splitJobs());
                for (ApiPersonDTO entry : cast) {
                    Integer amount = jobMap.get(entry.getJobType());
                    if (amount == null) {
                        episode.addCast(entry);
                    } else if (amount > 0) {
                        episode.addCast(entry);
                        amount--;
                        jobMap.put(entry.getJobType(), amount);
                    }
                }
            }
        } else if (options.isAllJobTypes()) {
            for (ApiEpisodeDTO episode : results) {
                episode.setCast(
                        getCastForId(MetaDataType.EPISODE, episode.getId(), options.splitDataItems(), null));
            }
        }
    }
    wrapper.setResults(results);
}

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

License:Open Source License

public void getSingleVideo(ApiWrapperSingle<ApiVideoDTO> wrapper) {
    OptionsIndexVideo options = (OptionsIndexVideo) wrapper.getOptions();
    IndexParams params = new IndexParams(options);
    MetaDataType type = MetaDataType.fromString(options.getType());

    if (CollectionUtils.isNotEmpty(params.getDataItems())) {
        LOG.trace("Getting additional data items: {} ", params.getDataItems());
    }/*from  w ww.j  a v  a2s .c  o  m*/

    String sql;
    if (type == MetaDataType.MOVIE) {
        sql = generateSqlForVideo(true, params);
    } else if (type == MetaDataType.SERIES) {
        sql = generateSqlForSeries(params);
    } else if (type == MetaDataType.SEASON) {
        sql = generateSqlForSeason(params);
    } else {
        throw new UnsupportedOperationException(
                "Unable to process type '" + type + "' (Original: '" + options.getType() + "')");
    }
    LOG.trace("SQL for {}-{}: {}", type, params.getId(), sql);

    SqlScalars sqlScalars = new SqlScalars(sql);

    sqlScalars.addScalar(ID, LongType.INSTANCE);
    sqlScalars.addScalar("videoTypeString", StringType.INSTANCE);
    sqlScalars.addScalar(TITLE, StringType.INSTANCE);
    sqlScalars.addScalar(ORIGINAL_TITLE, StringType.INSTANCE);
    sqlScalars.addScalar(VIDEO_YEAR, IntegerType.INSTANCE);
    sqlScalars.addScalar(SERIES_ID, LongType.INSTANCE);
    sqlScalars.addScalar(SEASON_ID, LongType.INSTANCE);
    sqlScalars.addScalar(SEASON, LongType.INSTANCE);
    sqlScalars.addScalar(WATCHED, BooleanType.INSTANCE);
    // add Scalars for additional data item columns
    DataItemTools.addDataItemScalars(sqlScalars, params.getDataItems());
    // add additional parameters
    params.addScalarParameters(sqlScalars);

    List<ApiVideoDTO> queryResults = executeQueryWithTransform(ApiVideoDTO.class, sqlScalars, wrapper);
    LOG.trace("Found {} results for ID {}", queryResults.size(), params.getId());
    if (CollectionUtils.isNotEmpty(queryResults)) {
        ApiVideoDTO video = queryResults.get(0);

        if (params.hasDataItem(DataItem.GENRE)) {
            LOG.trace("Adding genres for ID {}", options.getId());
            video.setGenres(getGenresForId(type, options.getId()));
        }

        if (params.hasDataItem(DataItem.STUDIO)) {
            LOG.trace("Adding studios for ID {}", options.getId());
            video.setStudios(getStudiosForId(type, options.getId()));
        }

        if (options.hasDataItem(DataItem.COUNTRY)) {
            LOG.trace("Adding countries for ID {}", options.getId());
            video.setCountries(getCountriesForId(type, options.getId()));
        }

        if (params.hasDataItem(DataItem.CERTIFICATION)) {
            LOG.trace("Adding certifications for ID {}", options.getId());
            video.setCertifications(getCertificationsForId(type, options.getId()));
        }

        if (params.hasDataItem(DataItem.RATING)) {
            LOG.trace("Adding ratings for ID {}", options.getId());
            video.setRatings(getRatingsForId(type, options.getId()));
        }

        if (options.hasDataItem(DataItem.AWARD)) {
            LOG.trace("Adding awards for ID {}", options.getId());
            video.setAwards(getAwardsForId(type, options.getId()));
        }

        if (options.hasDataItem(DataItem.EXTERNALID)) {
            LOG.trace("Adding external IDs for ID {}", options.getId());
            video.setExternalIds(getExternalIdsForId(type, options.getId()));
        }

        if (options.hasDataItem(DataItem.BOXSET)) {
            LOG.trace("Adding boxed sets for ID {}", options.getId());
            video.setBoxedSets(getBoxedSetsForId(type, options.getId()));
        }

        if (params.hasDataItem(DataItem.ARTWORK)) {
            LOG.trace("Adding artwork for ID {}", options.getId());
            Map<Long, List<ApiArtworkDTO>> artworkList;
            if (CollectionUtils.isNotEmpty(options.getArtworkTypes())) {
                artworkList = getArtworkForId(type, options.getId(), options.getArtworkTypes());
            } else {
                artworkList = getArtworkForId(type, options.getId());
            }

            if (artworkList.containsKey(options.getId())) {
                video.setArtwork(artworkList.get(options.getId()));
            }
        }

        if (params.hasDataItem(DataItem.FILES)) {
            LOG.trace("Adding files for ID {}", options.getId());
            video.setFiles(getFilesForId(type, options.getId()));
        }

        if (params.hasDataItem(DataItem.TRAILER)) {
            LOG.trace("Adding trailers for ID {}", options.getId());
            video.setTrailers(getTrailersForId(type, options.getId()));
        }

        if (MapUtils.isNotEmpty(options.splitJobs())) {
            Set<String> jobs = options.getJobTypesAsSet();
            LOG.trace("Adding jobs for ID {}: {}", options.getId(), jobs);

            List<ApiPersonDTO> cast = getCastForId(type, options.getId(), options.splitDataItems(), jobs);

            // just add given amount for jobs to cast
            Map<JobType, Integer> jobMap = new HashMap<>(options.splitJobs());
            for (ApiPersonDTO entry : cast) {
                Integer amount = jobMap.get(entry.getJobType());
                if (amount == null) {
                    video.addCast(entry);
                } else if (amount > 0) {
                    video.addCast(entry);
                    amount--;
                    jobMap.put(entry.getJobType(), amount);
                }
            }
        } else if (options.isAllJobTypes()) {
            LOG.trace("Adding all jobs for ID {}", options.getId());
            video.setCast(getCastForId(type, options.getId(), params.getDataItems(), null));
        }

        wrapper.setResult(video);
    } else {
        wrapper.setResult(null);
    }
    wrapper.setStatusCheck();
}

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

License:Open Source License

/**
 * Get a list of the files associated with a video ID.
 *
 * @param type/*www .  j a  v  a2 s  .com*/
 * @param id
 * @return
 */
private List<ApiFileDTO> getFilesForId(MetaDataType type, Long id) {
    // Build the SQL statement
    StringBuilder sbSQL = new StringBuilder();
    sbSQL.append(
            "SELECT mf.id as id, mf.extra as extra, mf.part as part, mf.part_title as partTitle, mf.movie_version as version, ");
    sbSQL.append(
            "mf.container as container, mf.codec as codec, mf.codec_format as codecFormat, mf.codec_profile as codecProfile, ");
    sbSQL.append("mf.bitrate as bitrate, mf.overall_bitrate as overallBitrate, mf.fps as fps, ");
    sbSQL.append(
            "mf.width as width, mf.height as height, mf.aspect_ratio as aspectRatio, mf.runtime as runtime, mf.video_source as videoSource, ");
    sbSQL.append(
            "sf.id as fileId, sf.full_path as fileName, sf.file_date as fileDate, sf.file_size as fileSize, ");

    if (type == MetaDataType.MOVIE) {
        sbSQL.append("null as season, null as episode ");
        sbSQL.append("FROM mediafile_videodata mv, mediafile mf, stage_file sf ");
        sbSQL.append("WHERE mv.videodata_id=:id ");
    } else if (type == MetaDataType.SERIES) {
        sbSQL.append("sea.season, vd.episode ");
        sbSQL.append("FROM mediafile_videodata mv, mediafile mf, stage_file sf, season sea, videodata vd ");
        sbSQL.append("WHERE sea.series_id=:id ");
        sbSQL.append("and vd.season_id=sea.id ");
        sbSQL.append("and mv.videodata_id=vd.id ");
    } else if (type == MetaDataType.SEASON) {
        sbSQL.append("sea.season, vd.episode ");
        sbSQL.append("FROM mediafile_videodata mv, mediafile mf, stage_file sf, season sea, videodata vd ");
        sbSQL.append("WHERE sea.id=:id ");
        sbSQL.append("and vd.season_id=sea.id ");
        sbSQL.append("and mv.videodata_id=vd.id ");
    } else if (type == MetaDataType.EPISODE) {
        sbSQL.append("sea.season, vd.episode ");
        sbSQL.append("FROM mediafile_videodata mv, mediafile mf, stage_file sf, season sea, videodata vd ");
        sbSQL.append("WHERE vd.id=:id ");
        sbSQL.append("and vd.season_id=sea.id ");
        sbSQL.append("and mv.videodata_id=vd.id ");
    }

    sbSQL.append("and mv.mediafile_id=mf.id ");
    sbSQL.append("and sf.mediafile_id=mf.id ");
    sbSQL.append("and sf.file_type='");
    sbSQL.append(FileType.VIDEO.toString());
    sbSQL.append("' and sf.status not in ('");
    sbSQL.append(StatusType.DUPLICATE.toString());
    sbSQL.append("','");
    sbSQL.append(StatusType.DELETED.toString());
    sbSQL.append("') ");

    if (type == MetaDataType.SERIES || type == MetaDataType.SEASON) {
        sbSQL.append("ORDER BY sea.season ASC, vd.episode ASC");
    }

    SqlScalars sqlScalars = new SqlScalars(sbSQL);
    sqlScalars.addScalar(ID, LongType.INSTANCE);
    sqlScalars.addScalar("extra", BooleanType.INSTANCE);
    sqlScalars.addScalar("part", IntegerType.INSTANCE);
    sqlScalars.addScalar("partTitle", StringType.INSTANCE);
    sqlScalars.addScalar("version", StringType.INSTANCE);
    sqlScalars.addScalar("container", StringType.INSTANCE);
    sqlScalars.addScalar("codec", StringType.INSTANCE);
    sqlScalars.addScalar("codecFormat", StringType.INSTANCE);
    sqlScalars.addScalar("codecProfile", StringType.INSTANCE);
    sqlScalars.addScalar("bitrate", IntegerType.INSTANCE);
    sqlScalars.addScalar("overallBitrate", IntegerType.INSTANCE);
    sqlScalars.addScalar("fps", FloatType.INSTANCE);
    sqlScalars.addScalar("width", IntegerType.INSTANCE);
    sqlScalars.addScalar("height", IntegerType.INSTANCE);
    sqlScalars.addScalar("aspectRatio", StringType.INSTANCE);
    sqlScalars.addScalar("runtime", IntegerType.INSTANCE);
    sqlScalars.addScalar("videoSource", StringType.INSTANCE);
    sqlScalars.addScalar("fileId", LongType.INSTANCE);
    sqlScalars.addScalar("fileName", StringType.INSTANCE);
    sqlScalars.addScalar("fileDate", TimestampType.INSTANCE);
    sqlScalars.addScalar("fileSize", LongType.INSTANCE);
    sqlScalars.addScalar(SEASON, LongType.INSTANCE);
    sqlScalars.addScalar(EPISODE, LongType.INSTANCE);
    sqlScalars.addParameter(ID, id);

    List<ApiFileDTO> results = executeQueryWithTransform(ApiFileDTO.class, sqlScalars, null);
    if (CollectionUtils.isNotEmpty(results)) {
        for (ApiFileDTO file : results) {
            file.setAudioCodecs(this.getAudioCodecs(file.getId()));
            file.setSubtitles(this.getSubtitles(file.getId()));
        }
    }
    return results;
}

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

License:Open Source License

private List<ApiSubtitleDTO> getSubtitles(long mediaFileId) {
    StringBuilder sbSQL = new StringBuilder();
    sbSQL.append(/*from  w w  w  .ja  v  a  2s.c  om*/
            "SELECT st.counter, st.format, st.language_code as languageCode, st.default_flag AS defaultFlag,");
    sbSQL.append("st.forced_flag AS forcedFlag, sf.full_path as filePath ");
    sbSQL.append("FROM subtitle st ");
    sbSQL.append("LEFT OUTER JOIN stage_file sf ON sf.id=st.stagefile_id ");
    sbSQL.append("WHERE st.mediafile_id=:id ");
    sbSQL.append("ORDER BY sf.full_path DESC, st.counter ASC");

    SqlScalars sqlScalars = new SqlScalars(sbSQL);
    sqlScalars.addScalar("format", StringType.INSTANCE);
    sqlScalars.addScalar("languageCode", StringType.INSTANCE);
    sqlScalars.addScalar("defaultFlag", BooleanType.INSTANCE);
    sqlScalars.addScalar("forcedFlag", BooleanType.INSTANCE);
    sqlScalars.addScalar("filePath", StringType.INSTANCE);
    sqlScalars.addParameter(ID, mediaFileId);

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

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//from w  w  w  . j  a  v  a2 s  .c o m
 * @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

public void getSeriesInfo(ApiWrapperList<ApiSeriesInfoDTO> wrapper) {
    OptionsIdArtwork options = (OptionsIdArtwork) wrapper.getOptions();
    Long id = options.getId();/*ww w . j  a  va 2s .  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();//from  w w w .  java2s . com

    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 list of external IDs for a metadata object.
 * /* w  w w  .  java 2s. 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);
}

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

License:Open Source License

public ApiBoxedSetDTO getBoxedSet(ApiWrapperSingle<ApiBoxedSetDTO> wrapper) {
    OptionsBoxedSet options = (OptionsBoxedSet) wrapper.getOptions();
    SqlScalars sqlScalars = generateSqlForBoxedSet(options);

    List<ApiBoxedSetDTO> boxsets = executeQueryWithTransform(ApiBoxedSetDTO.class, sqlScalars, wrapper);
    if (CollectionUtils.isEmpty(boxsets)) {
        return null;
    }//from w  w  w.  jav a 2s.  com

    // get the first boxed set which has been retrieved by the given id
    ApiBoxedSetDTO boxedSet = boxsets.get(0);

    if (options.hasDataItem(DataItem.MEMBER)) {
        // get members
        sqlScalars = new SqlScalars();
        sqlScalars.addToSql("SELECT vd.id");
        sqlScalars.addToSql(SQL_COMMA_SPACE_QUOTE + MetaDataType.MOVIE + SQL_AS_VIDEO_TYPE_STRING);
        sqlScalars.addToSql(
                ", bo1.ordering, vd.title, vd.title_original AS originalTitle, vd.publication_year AS year,vd.release_date AS releaseDate,");
        sqlScalars.addToSql("min(vd.watched_nfo or vd.watched_file or vd.watched_api) as watched");
        sqlScalars.addToSql(DataItemTools.addSqlDataItems(options.splitDataItems(), "vd").toString());
        sqlScalars.addToSql("FROM boxed_set_order bo1");
        sqlScalars.addToSql("JOIN videodata vd ON bo1.videodata_id=vd.id");
        sqlScalars.addToSql("WHERE bo1.boxedset_id=" + options.getId());
        sqlScalars.addToSql(SQL_UNION);
        sqlScalars.addToSql("SELECT ser.id");
        sqlScalars.addToSql(SQL_COMMA_SPACE_QUOTE + MetaDataType.SERIES + SQL_AS_VIDEO_TYPE_STRING);
        sqlScalars.addToSql(
                ", bo2.ordering, ser.title, ser.title_original AS originalTitle, ser.start_year AS year,null as releaseDate,");
        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=ser.id) as watched");
        sqlScalars.addToSql(DataItemTools.addSqlDataItems(options.splitDataItems(), "ser").toString());
        sqlScalars.addToSql("FROM boxed_set_order bo2");
        sqlScalars.addToSql("JOIN series ser ON bo2.series_id=ser.id");
        sqlScalars.addToSql("WHERE bo2.boxedset_id=" + options.getId());
        sqlScalars.addToSql(options.getSortString());

        sqlScalars.addScalar(ID, LongType.INSTANCE);
        sqlScalars.addScalar("videoTypeString", StringType.INSTANCE);
        sqlScalars.addScalar("ordering", IntegerType.INSTANCE);
        sqlScalars.addScalar(TITLE, StringType.INSTANCE);
        sqlScalars.addScalar(ORIGINAL_TITLE, StringType.INSTANCE);
        sqlScalars.addScalar(YEAR, IntegerType.INSTANCE);
        sqlScalars.addScalar("releaseDate", DateType.INSTANCE);
        sqlScalars.addScalar(WATCHED, BooleanType.INSTANCE);
        DataItemTools.addDataItemScalars(sqlScalars, options.splitDataItems());

        List<ApiBoxedSetMemberDTO> members = this.executeQueryWithTransform(ApiBoxedSetMemberDTO.class,
                sqlScalars, null);
        boxedSet.setMembers(members);
    }

    if (options.hasDataItem(DataItem.ARTWORK)) {
        LOG.trace("Adding artwork for ID {}", options.getId());
        Map<Long, List<ApiArtworkDTO>> artworkList;
        if (CollectionUtils.isNotEmpty(options.getArtworkTypes())) {
            artworkList = getArtworkForId(MetaDataType.BOXSET, options.getId(), options.getArtworkTypes());
        } else {
            artworkList = getArtworkForId(MetaDataType.BOXSET, options.getId());
        }

        if (artworkList.containsKey(options.getId())) {
            boxedSet.setArtwork(artworkList.get(options.getId()));
        }
    }

    return boxedSet;
}