public async Task <RecommendationsResponse> GetRecommendationsAsync(RecommendationRequest recommendationRequest)
{
#region Create seed lists if null
if (recommendationRequest.SeedArtists == null)
{
recommendationRequest.SeedArtists = new List <string>();
}
if (recommendationRequest.SeedGenres == null)
{
recommendationRequest.SeedGenres = new List <string>();
}
if (recommendationRequest.SeedTracks == null)
{
recommendationRequest.SeedTracks = new List <string>();
}
#endregion Create seed lists if null
await FillSeedTracks(recommendationRequest);
string query = FormatRecommendationQuery(recommendationRequest);
return(await _requestHandler.GetTrackRecommendations(query));
}
private async Task FillSeedTracks(RecommendationRequest recommendationRequest)
{
List <TracksSearchResponse> tracksToAdd = new List <TracksSearchResponse>();
if (recommendationRequest.SeedPlaylists != null && recommendationRequest.SeedPlaylists.Any()) //If the user has selected categories, choose tracks according to those
{
foreach (var playlist in recommendationRequest.SeedPlaylists)
{
tracksToAdd.Add(await _requestHandler.GetPlaylistTracksAsync(playlist));
}
}
else // else take user top tracks
{
tracksToAdd.Add(await _requestHandler.GetUserTopTracksAsync());
}
int tracksFromEach = (5 - GetSeedCount(recommendationRequest)) / tracksToAdd.Count();
if (tracksFromEach < 1)
{
tracksFromEach = 1;
}
foreach (var tracksSearch in tracksToAdd)
{
foreach (var track in tracksSearch.Tracks.Take(tracksFromEach))
{
if (GetSeedCount(recommendationRequest) < 5)
{
recommendationRequest.SeedTracks.Add(track.Id);
}
}
}
}
public async Task <IActionResult> CategoryPlaylists(RecommendationRequest request)
{
if (_spotifyService == null)
{
_spotifyService = await GetSpotifyServiceAsync();
}
List <Playlist> playlists = new List <Playlist>();
if (request.SeedCategories == null)
{
return(PartialView(playlists));
}
foreach (var category in request.SeedCategories)
{
var pr = await _spotifyService.GetCategoryPlaylists(category);
playlists.AddRange(pr.PlaylistsData.Playlists);
}
if (playlists.Any())
{
return(PartialView(playlists));
}
else
{
return(BadRequest("Not found."));
}
}
public static (bool, string) IsValid(RecommendationRequest req)
{
if (req.Score > 0 && req.Score <= 10)
{
return(true, null);
}
return(false, "Score must be between 0 and 10");
}
public async Task Post(RecommendationRequest req)
{
string url = $"{_baseUrl}/Recommendation/";
using (HttpClient httpClient = new HttpClient())
{
StringContent content = new StringContent(JsonConvert.SerializeObject(req), Encoding.UTF8, "application/json");
await httpClient.PostAsync(url, content);
}
}
private SeedData ProcessRequest(RecommendationRequest recommendationRequest)
{
var seedData = new SeedData();
foreach (var skill in recommendationRequest.ProjectSkills)
{
var propertyInfo = seedData.GetType().GetProperty(skill.Tag.ToLower());
propertyInfo.SetValue(seedData, Convert.ChangeType(skill.Weight, propertyInfo.PropertyType), null);
}
return(seedData);
}
private int GetSeedCount(RecommendationRequest recommendationRequest)
{
int result = 0;
result += recommendationRequest.SeedArtists != null?recommendationRequest.SeedArtists.Count() : 0;
result += recommendationRequest.SeedGenres != null?recommendationRequest.SeedGenres.Count() : 0;
result += recommendationRequest.SeedTracks != null?recommendationRequest.SeedTracks.Count() : 0;
return(result);
}
public virtual async System.Threading.Tasks.Task <IEnumerable <RecommendationResult> > GetRecommendationContent(HttpContextBase httpContext,
ContentRecommendationViewModel requestModel)
{
var recommendationRequest = new RecommendationRequest
{
siteId = requestModel.SiteId,
context = new Context {
contentId = requestModel.ContentId, languageId = requestModel.LanguageId
},
numberOfRecommendations = requestModel.NumberOfRecommendations == 0 ? 3 : requestModel.NumberOfRecommendations
};
return(await _personalizationRecommendationService.Get(httpContext, recommendationRequest));
}
public Task <RecommendationResponse> GetRecommendationsAsync(RecommendationRequest recommendationRequest)
{
var predictionData = PredictValue(recommendationRequest);
var candidates = predictionData.userData
.Where(p => p.SelectedClusterId.Equals(predictionData.prediction.SelectedClusterId))
.OrderBy(x => x.Distance[x.SelectedClusterId])
.Select(Candidate.FromPrediction)
.ToList();
return(Task.FromResult(new RecommendationResponse
{
Matches = candidates
}));
}
public async Task <bool> RecommendMovie(RecommendationRequest recommmendationRequest)
{
var response = GetMovieDetailResponse(recommmendationRequest.MovieId);
if (response.Data != null)
{
string htmlMessage = HtmlHelper.ConvertToHtml(response.Data);
bool isSent = await _emailService.Send(htmlMessage, _appConfiguration.SmtpInfo.subject, new List <string> {
recommmendationRequest.Email
});
return(isSent);
}
return(false);
}
public async Task <ActionResult> Post([FromBody] RecommendationRequest req)
{
var isValid = RecommendationValidator.IsValid(req);
if (isValid.Item1)
{
await _bingeWatchService.UpdateContentWatchingStatus(req.UserId, req.ContentId, Enums.ContentWatchingStatus.Finished);
await _bingeWatchService.UpdateContentRecomendation(req.ContentId, req.UserId, req.Score);
return(Ok());
}
return(BadRequest(isValid.Item2));
}
public Task <RecommendationResponse> GetRecommendationsAsync(RecommendationRequest recommendationRequest)
{
var candidates = new List <Candidate>
{
new Candidate
{
UserId = "mgonzalez",
Name = "Marlon",
LastName = "González",
Score = _random.NextDouble()
},
new Candidate
{
UserId = "yvaldes",
Name = "Yanara",
LastName = "Valdes",
Score = _random.NextDouble()
},
new Candidate
{
UserId = "dalvarez",
Name = "Delia",
LastName = "Álvarez",
Score = _random.NextDouble()
},
new Candidate
{
UserId = "wclaro",
Name = "Willian",
LastName = "Claro",
Score = _random.NextDouble()
},
new Candidate
{
UserId = "ktamayo",
Name = "Karel",
LastName = "Tamayo",
Score = _random.NextDouble()
}
}
.OrderByDescending(x => x.Score);
return(Task.FromResult(new RecommendationResponse
{
Matches = candidates
}));
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="client">(Required) Spotify Sdk Client</param>
/// <param name="trackType">(Required) Track Type</param>
/// <param name="value">(Required) Only for TrackType.Search - Track Search Term, TrackType.Album - Spotify Album Id and TrackType.Artist - Spotify Artist Id</param>
/// <param name="multipleTrackIds">(Required) Only for TrackType.Multiple - Multiple Spotify Track Ids</param>
/// <param name="searchIsExternal">(Optional) Only for TrackType.Search, If true the response will include any relevant audio content that is hosted externally</param>
/// <param name="recommendation">(Optional) Only for TrackType.Recommended - Recommendation Request</param>
public ListTrackViewModel(
ISpotifySdkClient client,
TrackType trackType,
string value = null,
List <string> multipleTrackIds = null,
bool?searchIsExternal = null,
RecommendationRequest recommendation = null)
: base(client, new TracksRequest()
{
TrackType = trackType,
Value = value,
MultipleTrackIds = multipleTrackIds,
SearchIsExternal = searchIsExternal,
Recommendation = recommendation
})
{
}
public async Task <IActionResult> RecommendMovie([FromBody] RecommendationRequest recommendRquest)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.Values));
}
bool isSent = await _movieService.RecommendMovie(recommendRquest);
return(Ok(isSent));
}
catch (System.Exception ex)
{
_logger.LogError(ex, ex.Message);
return(StatusCode((int)HttpStatusCode.InternalServerError));
}
}
public async Task <ActionResult> Post(RecommendationRequest req)
{
string url = $"{_baseUrl}/Recommendation/";
using (HttpClient httpClient = new HttpClient())
{
StringContent content = new StringContent(JsonConvert.SerializeObject(req), Encoding.UTF8, "application/json");
var res = await httpClient.PostAsync(url, content);
if (!res.IsSuccessStatusCode)
{
var response = await res.Content.ReadAsStringAsync();
return(new BadRequestObjectResult(response));
}
}
return(new OkResult());
}
/// <summary>
/// Get Recommendations
/// </summary>
/// <param name="client">Spotify Sdk Client</param>
/// <param name="mapper">Mapper</param>
/// <param name="country">Country</param>
/// <param name="recommendationRequest">Recommendation Request</param>
/// <returns>Navigation Response of Track Response</returns>
public static async Task <NavigationResponse <TrackResponse> > GetRecommendationsAsync(
this ISpotifyClient client,
IMapper mapper,
string country,
RecommendationRequest recommendationRequest)
{
var recommended = await client.LookupRecommendationsAsync(
seedArtists : recommendationRequest?.SeedArtistIds,
seedGenres :
Helpers.GetListFromString(recommendationRequest?.SeedGenre)
?? recommendationRequest?.SeedGenres,
seedTracks : recommendationRequest?.SeedTrackIds,
limit : recommendationRequest?.TargetTotal,
market : country,
minTuneableTrack : mapper.Map(recommendationRequest?.MinimumTuneableTrack),
maxTuneableTrack : mapper.Map(recommendationRequest?.MaximumTuneableTrack),
targetTuneableTrack : mapper.Map(recommendationRequest?.TargetTuneableTrack));
return(mapper.MapFromRecommendationResponse(recommended));
}
public async Task <IActionResult> Recommendations(RecommendationRequest request)
{
if (_spotifyService == null)
{
_spotifyService = await GetSpotifyServiceAsync();
}
var recommendations = await _spotifyService.GetRecommendationsAsync(request);
if (recommendations != null)
{
var recommendedTracks = recommendations.Tracks;
return(PartialView(recommendedTracks));
}
else
{
return(BadRequest("Not found."));
}
}
/// <summary>
/// Performs recommendation for specified users.
/// </summary>
/// <param name="model">Model instance.</param>
/// <param name="users">Users to get recommendation.</param>
/// <param name="recordsCount">Number of items to recommend for each user.</param>
/// <param name="filterItems">Items to filter.</param>
/// <param name="filterItemsMode">Mode of filter,</param>
/// <param name="filterAlreadyInteractedItems">Filter out already interacted items from prediction.</param>
/// <param name="userItems">Updated users items.</param>
/// <param name="recalculateUsers">Recalculate users recommendations using <see cref="userItems"/></param>
public RecommendationResponse Recommend(MLModelConfig model, List <Guid> users, int recordsCount = 10,
List <Guid> filterItems = null,
RecommendationFilterItemsMode filterItemsMode = RecommendationFilterItemsMode.White,
bool filterAlreadyInteractedItems = true, List <DatasetValue> userItems = null,
bool recalculateUsers = false)
{
RecommendationRequest request = new RecommendationRequest {
ModelId = model.ModelInstanceUId,
PredictionParams = new RecommendationInput {
UserIds = users.Select(e => e.ToString()).ToList(),
PredictionRecordsCount = recordsCount,
FilterItems = filterItems?.Select(e => e.ToString()).ToList() ?? new List <string>(),
FilterItemsMode = filterItemsMode.ToString().ToLowerInvariant(),
FilterAlreadyInteractedItems = filterAlreadyInteractedItems,
UserItems = userItems,
RecalculateUsers = recalculateUsers
}
};
return(Post <RecommendationResponse>(model.PredictionEndpoint, request, RecommendationTimeoutSec));
}
public string GetRecommendations(ApiRecommendationRequest request)
{
_recommendationService = ServiceLocator.Current.GetInstance <IRecommendationService>();
var rRequest = new RecommendationRequest
{
siteId = request.siteId,
context = new Context {
contentId = request.contentId, languageId = request.languageId
},
numberOfRecommendations = request.numberOfRecommendations == 0 ? 3 : request.numberOfRecommendations
};
var context = Request.Properties["MS_HttpContext"] as HttpContextWrapper;
var task = Task.Run(async() => await _recommendationService.Get(context, rRequest));
var recommendationResults = task.Result;
var htmlResult = new StringBuilder();
if (recommendationResults != null)
{
htmlResult.Append("<h2>Recommendations</h2>");
htmlResult.Append("<ul>");
var urlResolver = ServiceLocator.Current.GetInstance <IUrlResolver>();
foreach (var result in recommendationResults)
{
var friendlyUrl = urlResolver.GetUrl(result.Content.ContentLink);
htmlResult.Append($"<li><a onmouseup=\"Misc && Misc.setCookie('EPiServer_CMS_RecommendationId', '{result.RecommendationId}', 60);\" href=\"{friendlyUrl}\">{result.Content.Name}</a></li>");
}
htmlResult.Append("</ul>");
}
return(htmlResult.ToString());
}
private (ClusteringPrediction[] userData, ClusteringPrediction prediction) PredictValue(RecommendationRequest recommendationRequest)
{
string modelPath = Path.Combine(Environment.CurrentDirectory, "Data", "trainedModel.zip");
var inputPath = Path.Combine(Environment.CurrentDirectory, "Data", "user-languages.csv");
try
{
var data = MLContext.Data.LoadFromTextFile <SeedData>(
path: inputPath,
hasHeader: true,
separatorChar: ',');
// Load data preparation pipeline and trained model out dataPrepPipelineSchema);
ITransformer trainedModel = MLContext.Model.Load(modelPath, out var modelSchema);
var transformedDataView = trainedModel.Transform(data);
var predictionEngine = MLContext.Model.CreatePredictionEngine <SeedData, ClusteringPrediction>(trainedModel);
var prediction = predictionEngine.Predict(ProcessRequest(recommendationRequest));
ClusteringPrediction[] userData = MLContext.Data
.CreateEnumerable <ClusteringPrediction>(transformedDataView, false)
.ToArray();
//Plot/paint the clusters in a chart and open it with the by-default image-tool in Windows
//var plotLocation = Path.Combine(Directory.GetParent(modelPath).FullName, "userskillclusters.svg");
//SaveSegmentationPlotChart(userData, plotLocation);
return(userData, prediction);
}
catch (Exception ex)
{
throw ex;
}
}
private string FormatRecommendationQuery(RecommendationRequest recommendationRequest)
{
StringBuilder stringBuilder = new StringBuilder("?");
var c = System.Globalization.CultureInfo.InvariantCulture;
//Add all parameters for the reccomendation request
#region Build query
if (recommendationRequest.SeedArtists.Any())
{
stringBuilder.Append("seed_artists=");
foreach (var artist in recommendationRequest.SeedArtists)
{
stringBuilder.Append(artist);
if (artist != recommendationRequest.SeedArtists.Last())
{
stringBuilder.Append(",");
}
}
}
if (recommendationRequest.SeedGenres.Any())
{
if (stringBuilder.Length > 1)
{
stringBuilder.Append("&");
}
stringBuilder.Append("seed_genres=");
foreach (var genre in recommendationRequest.SeedGenres)
{
stringBuilder.Append(genre);
if (genre != recommendationRequest.SeedGenres.Last())
{
stringBuilder.Append(",");
}
}
}
if (recommendationRequest.SeedTracks.Any())
{
if (stringBuilder.Length > 1)
{
stringBuilder.Append("&");
}
stringBuilder.Append("seed_tracks=");
foreach (var track in recommendationRequest.SeedTracks)
{
stringBuilder.Append(track);
if (track != recommendationRequest.SeedTracks.Last())
{
stringBuilder.Append(",");
}
}
}
if (recommendationRequest.MinDanceAbility > 0)
{
if (stringBuilder.Length > 1)
{
stringBuilder.Append("&");
}
stringBuilder.Append("min_danceability=");
stringBuilder.Append((recommendationRequest.MinDanceAbility / 100).ToString("0.00", c));
}
if (recommendationRequest.MaxDanceAbility > 0)
{
if (stringBuilder.Length > 1)
{
stringBuilder.Append("&");
}
stringBuilder.Append("max_danceability=");
stringBuilder.Append((recommendationRequest.MaxDanceAbility / 100).ToString("0.00", c));
}
if (recommendationRequest.TargetDanceAbility > 0)
{
if (stringBuilder.Length > 1)
{
stringBuilder.Append("&");
}
stringBuilder.Append("target_danceability=");
stringBuilder.Append((recommendationRequest.TargetDanceAbility / 100).ToString("0.00", c));
}
if (recommendationRequest.TargetTempo > 60)
{
if (stringBuilder.Length > 1)
{
stringBuilder.Append("&");
}
stringBuilder.Append("target_tempo=");
stringBuilder.Append((recommendationRequest.TargetTempo).ToString("0.00", c));
}
#endregion Build query
return(stringBuilder.ToString());
}
/// <inheritdoc />
public Task <RecommendedContentItem[]> GetRecommendationsAsync(RecommendationRequest request)
{
return(PostAsync <RecommendedContentItem[]>($"{RecommendationEndpointRoutePrefix}/items", JsonConvert.SerializeObject(request)));
}
