VideoEntityTypes.h

Go to the documentation of this file.

/*
 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License").
 * You may not use this file except in compliance with the License.
 * A copy of the License is located at
 *
 *     http://aws.amazon.com/apache2.0/
 *
 * or in the "license" file accompanying this file. This file is distributed
 * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
 * express or implied. See the License for the specific language governing
 * permissions and limitations under the License.
 */

#ifndef ALEXA_CLIENT_SDK_VIDEOCONTENT_INCLUDE_ACSDK_VIDEOCONTENT_VIDEOENTITYTYPES_H_
#define ALEXA_CLIENT_SDK_VIDEOCONTENT_INCLUDE_ACSDK_VIDEOCONTENT_VIDEOENTITYTYPES_H_

#include <string>
#include <unordered_map>

#include <rapidjson/document.h>
#include <AVSCommon/Utils/Optional.h>

namespace alexaClientSDK {
namespace acsdkAlexaVideoCommon {

class VideoEntity {
public:
    enum class EntityType {
        ACTOR,
        APP,
        CHANNEL,
        CHARACTER,
        DIRECTOR,
        EPISODE,
        EVENT,
        FRANCHISE,
        GENRE,
        LEAGUE,
        MEDIA_TYPE,
        POPULARITY,
        PRODUCTION_COMPANY,
        RECENCY,
        SEASON,
        SPORT,
        SPORTS_TEAM,
        VIDEO,
        VIDEO_RESOLUTION
    };

    struct Actor {
        std::unordered_map<std::string, std::string> externalIds;
        std::string name;
    };

    struct App {
        std::unordered_map<std::string, std::string> externalIds;
        std::string name;
    };

    struct Channel {
        Channel(int channelNum) : channelNumber{channelNum} {};

        std::unordered_map<std::string, std::string> externalIds;
        int channelNumber;
        std::string channelCallSign;
        std::string uri;
        std::string name;
    };

    struct Character {
        std::unordered_map<std::string, std::string> externalIds;
        std::string name;
    };

    struct Director {
        std::unordered_map<std::string, std::string> externalIds;
        std::string name;
    };

    struct Episode {
        std::string number;
    };

    struct Event {
        std::unordered_map<std::string, std::string> externalIds;
        std::string name;
    };

    struct Franchise {
        std::string name;
    };

    struct Genre {
        std::unordered_map<std::string, std::string> externalIds;
        std::string name;
    };

    struct League {
        std::unordered_map<std::string, std::string> externalIds;
        std::string name;
    };

    struct Media {
        enum class Type {
            MOVIE,
            VIDEO,
            TV_SHOW
        };

        Media(Type typeValue) : type{typeValue} {};

        Type type;
    };

    struct Popularity {
        bool value;
    };

    struct ProductionCompany {
        std::string name;
    };

    struct Recency {
        enum class Type {
            NEW,
            OLD
        };

        Recency(Type recencyType) : type{recencyType} {};

        Type type;
    };

    struct Season {
        std::string number;
    };

    struct Sport {
        std::unordered_map<std::string, std::string> externalIds;
        std::string name;
    };

    struct SportsTeam {
        std::unordered_map<std::string, std::string> externalIds;
        std::string name;
    };

    struct Video {
        std::unordered_map<std::string, std::string> externalIds;
        std::string name;
    };

    struct VideoResolution {
        enum class Type {
            SD,
            HD,
            FOUR_K,
            EIGHT_K
        };

        VideoResolution(Type resolutionType) : type{resolutionType} {};

        Type type;
    };

    bool parseVideoEntityType(const rapidjson::Value& entityJson, VideoEntity::EntityType& entityType);

    bool parseActorEntity(const rapidjson::Value& entityJson, Actor& actor);

    bool parseAppEntity(const rapidjson::Value& entityJson, App& app);

    bool parseChannelEntity(const rapidjson::Value& entityJson, Channel& channel);

    bool parseCharacterEntity(const rapidjson::Value& entityJson, Character& character);

    bool parseDirectorEntity(const rapidjson::Value& entityJson, Director& director);

    bool parseEpisodeEntity(const rapidjson::Value& entityJson, Episode& episode);

    bool parseEventEntity(const rapidjson::Value& entityJson, Event& event);

    bool parseFranchiseEntity(const rapidjson::Value& entityJson, Franchise& franchise);

    bool parseGenreEntity(const rapidjson::Value& entityJson, Genre& genre);

    bool parseLeagueEntity(const rapidjson::Value& entityJson, League& league);

    bool parseMediaEntity(const rapidjson::Value& entityJson, Media& media);

    bool parsePopularityEntity(const rapidjson::Value& entityJson, Popularity& popularity);

    bool parseProductionCompanyEntity(const rapidjson::Value& entityJson, ProductionCompany& productionCompany);

    bool parseRecencyEntity(const rapidjson::Value& entityJson, Recency& recency);

    bool parseSeasonEntity(const rapidjson::Value& entityJson, Season& season);

    bool parseSportEntity(const rapidjson::Value& entityJson, Sport& sport);

    bool parseSportsTeamEntity(const rapidjson::Value& entityJson, SportsTeam& sportsTeam);

    bool parseVideoEntity(const rapidjson::Value& entityJson, Video& video);

    bool parseVideoResolutionEntity(const rapidjson::Value& entityJson, VideoResolution& videoResolution);

    static std::string convertEntityTypeToString(const VideoEntity::EntityType& entityType);
};

}  // namespace acsdkAlexaVideoCommon
}  // namespace alexaClientSDK
#endif  // ALEXA_CLIENT_SDK_VIDEOCONTENT_INCLUDE_ACSDK_VIDEOCONTENT_VIDEOENTITYTYPES_H_