Android Recommendations

reteno.getRecommendation();

reteno.recommendation

val recommendation = reteno.recommendation

/**
 * Obtain Recommendations.
 *
 * @param recomVariantId recommendation variant id. It is in r{recomId}v{variantId} format. Where recomId and variant Id are integer identifiers
 * @param recomRequest [com.reteno.core.domain.model.recommendation.get.RecomRequest] model
 * @param responseClass Class type to cast response to
 * @param responseCallback Type-safe [com.reteno.core.recommendation.GetRecommendationResponseCallback]
 *
 * @see [com.reteno.core.domain.model.recommendation.get.RecomRequest]
 * @see [com.reteno.core.recommendation.GetRecommendationResponseCallback]
 */
fun <T : RecomBase> fetchRecommendation(
    recomVariantId: String,
    recomRequest: RecomRequest,
    responseClass: Class<T>,
    responseCallback: GetRecommendationResponseCallback<T>
)

/**
 * This class describes the paramter model for getting Recommendations from Reteno SDK
 *
 * Return all product fields if a request does not contain fields parameter.
 *
 * Return only productId if fields array in a request is empty.
 *
 * @property products product IDs for product-based algorithms
 * @property category product category key for category-based algorithms
 * @property fields fields to return in response. If fields is null - all fields in the model returned
 * @property filters additional algorithm filters map. Filters are not supported yet. Reserved for the future.
 */
data class RecomRequest @JvmOverloads constructor(
    val products: List<String>?,
    val category: String?,
    val fields: List<String>? = null,
    val filters: RecomFilter? = null
)

data class RecomFilter(
    val name: String,
    val values: List<String>
)

interface GetRecommendationResponseCallback<T : RecomBase> {

    /**
     * @param response Response casted to a provided type
     */
    fun onSuccess(response: Recoms<T>)

    /**
     * @param response This callback is invoked if casting to a provided type fails. Provides raw JSON String
     */
    fun onSuccessFallbackToJson(response: String)

    /**
     * @param statusCode Rest status code (500, 400, etc)
     * @param response response message from the server
     * @param throwable exception thrown returned in this parameter if any
     */
    fun onFailure(statusCode: Int?, response: String?, throwable: Throwable?)
}

data class RecommendationResponse(
    @SerializedName("productId")
    override val productId: String,
    @SerializedName("descr")
    val descr: String?
) : RecomBase
```
`RecomBase`:

```kotlin
interface RecomBase {
    val productId: String
}

public class RecommendationResponse implements RecomBase {

    @SerializedName("productId")
    private String productId;
    @SerializedName("descr")
    private String descr;

    public RecommendationResponse(String productId, String descr) {
        this.productId = productId;
        this.descr = descr;
    }

    @NonNull
    @Override
    public String getProductId() {
        return productId;
    }

    public String getDescr() {
        return descr;
    }
}

val request = RecomRequest(
    products = listOf("product1", "product2"),
    category = null,
    fields = listOf("productId", "descr", "date_created_as", "date_created_es"),
    filters = null
)

reteno.recommendation.fetchRecommendation<RecommendationResponse>(
    "r123v123",
    request,
    RecommendationResponse::class.java,
    object : GetRecommendationResponseCallback<RecommendationResponse> {
        override fun onSuccess(response: Recoms<RecommendationResponse>) {
            // handle success
        }

        override fun onSuccessFallbackToJson(response: String) {
            // handle success when casting failed
        }

        override fun onFailure(statusCode: Int?, response: String?, throwable: Throwable?) {
            // handle error
        }
    })

RecomRequest request = new RecomRequest(
    List.of("prodcut1", "product2"), 
    category, 
    List.of("productId", "descr", "date_created_as", "date_created_es"), 
    null
);


getReteno().getRecommendation().fetchRecommendation("r123v123", request, RecommendationResponse.class, new GetRecommendationResponseCallback<RecommendationResponse>() {
    @Override
    public void onSuccess(@NonNull Recoms<RecommendationResponse> response) {
        // handle success
    }

    @Override
    public void onSuccessFallbackToJson(@NonNull String response) {
        // success when casting failed
    }

    @Override
    public void onFailure(@Nullable Integer statusCode, @Nullable String response, @Nullable Throwable throwable) {
        // handle error
    }
});

data class Recoms<T: RecomBase>(
    val recoms: List<T>,
)

/**
 * Log recommendation events
 * @param recomEvents - recommendation event to be logged
 *
 * @see [com.reteno.core.domain.model.recommendation.post.RecomEvents]
 */
fun logRecommendations(recomEvents: RecomEvents)

/**
 * Model to log Recommendation events
 *
 * @param recomVariantId REQUIRED. Recommendation variant id. It is in r{recomId}v{variantId} format. Where recomId and variant Id are integer identifiers
 * @param recomEvents list of [com.reteno.core.domain.model.recommendation.post.RecomEvent]
 */
data class RecomEvents(
    val recomVariantId: String,
    val recomEvents: List<RecomEvent>?
)

/**
 * Recommendation event
 *
 * @property recomEventType REQUIRED. Can be either IMPRESSIONS or CLICKS
 * @property occurred REQUIRED. Time in [java.time.ZonedDateTime]. Usually
 * ```
 * ZoneDateTime.now()
 * ```
 * @property productId REQUIRED. Id of the product
 *
 * @see [com.reteno.core.domain.model.recommendation.post.RecomEventType]
 */
data class RecomEvent(
    val recomEventType: RecomEventType,
    val occurred: ZonedDateTime,
    val productId: String
)

enum class RecomEventType {
    IMPRESSIONS, CLICKS
}

val recomEvent1 = RecomEvent(RecomEventType.CLICKS, ZonedDateTime.now(), "product1")
val recomEvent2 = RecomEvent(RecomEventType.IMPRESSIONS, ZonedDateTime.now(), "product2")
val eventList: List<RecomEvent> = listOf(recomEvent1, recomEvent2)

val recomEvents = RecomEvents("r123v123", eventList)
reteno.recommendation.logRecommendations(recomEvents)

RecomEvent recomEvent1 = new RecomEvent(RecomEventType.CLICKS, ZonedDateTime.now(), "product1");
RecomEvent recomEvent2 = new RecomEvent(RecomEventType.IMPRESSIONS, ZonedDateTime.now(), "product2");
List<RecomEvent> eventList = new ArrayList<>();
eventList.add(recomEvent1);
eventList.add(recomEvent2);

RecomEvents recomEvents = new RecomEvents("r123v123", eventList);
getReteno().getRecommendation().logRecommendations(recomEvents);