public async Task <IActionResult> CreateFilm([FromBody] CreateFilmRequest request)
{
IActionResult result = null;
await _eventService.Subscribe <ValidationFailedEvent>((failedEvent) =>
{
result = FromFailedValidationResult(failedEvent);
});
await _eventService.Subscribe <FilmCreatedEvent>((createdEvent) =>
{
result = CreatedAtAction(
nameof(GetFilm),
new { id = createdEvent.FilmId },
FilmResponse.FromDomainModel(createdEvent.Film));
});
await _eventService.IssueCommand(new CreateFilmCommand
{
Title = request.Title,
RuntimeInMinutes = request.RuntimeInMinutes,
UserId = _currentUserAccessor.CurrentUser.Id
});
return(result);
}
public async Task <IActionResult> SelectWatchNext([FromBody] SelectWatchNextRequest request)
{
IActionResult result = null;
await _eventService.Subscribe <ValidationFailedEvent>((failedEvent) =>
{
result = FromFailedValidationResult(failedEvent);
});
await _eventService.Subscribe <WatchNextSelectedEvent>((successEvent) =>
{
result = CreatedAtAction(
nameof(GetWatchNext),
new { id = successEvent.Film.Id },
FilmResponse.FromDomainModel(successEvent.Film));
});
await _eventService.IssueCommand(new SelectWatchNextCommand
{
UserId = _currentUserAccessor.CurrentUser.Id,
FilmId = request.FilmId,
SelectRandomFilm = request.SelectRandomFilm
});
return(result);
}
async void GetFilms()
{
var swapi = new SwapiService();
FilmResponse result = await swapi.GetFilms();
if (result != null)
{
Films = result.Films;
}
}
public async Task <IActionResult> GetWatchNext()
{
var record = await _watchNextReader.GetActiveWatchNext(_currentUserAccessor.CurrentUser.Id);
if (record == null)
{
return(NotFound());
}
return(Ok(FilmResponse.FromRecord(record)));
}
public async Task <IActionResult> GetFilm([FromRoute] long id)
{
var record = await _filmReader.GetFilmById(id);
if (record == null)
{
return(NotFound());
}
return(Ok(FilmResponse.FromRecord(record)));
}
/// <summary>
/// Upload the file to the network.
/// </summary>
private async void UploadButton(object sender, RoutedEventArgs e)
{
bool uploaded = await FileAPIController.UploadFile(user._savedInformation._id, fileLocation);
if (uploaded)
{
SetUploadMessage(Brushes.Green, "Uploaded file!");
FilmResponse res = await FileAPIController.GetAllFilesInNetwork(user._savedInformation._id);
main_files_listView.ItemsSource = res.data;
}
else
{
SetUploadMessage(Brushes.Red, "Failed to upload!");
}
}
/// <summary>
/// Called if the user had been logged in, it it downloads all users data.
/// </summary>
private async void SetupUI()
{
// Set the users details.
main_username_label.Content = user._savedInformation._username;
main_email_label.Content = user._savedInformation._email;
main_storage_label.Content = user._savedInformation._storageUsage + "MB/" + user._savedInformation._storageTier + "MB";
main_storage_amount.Text = holder._savedInformation.storageAmount.ToString();
main_allowStorage_check.IsChecked = user._savedInformation._allowStorage;
// Get all of the the uers files in the network.
FilmResponse res = await FileAPIController.GetAllFilesInNetwork(user._savedInformation._id);
main_files_listView.ItemsSource = res.data;
// Update the settings panel, changes button from Activate to Update etc.
UpdateSettingsPanel();
}
/// <summary>
/// Get all of the files the user has uploaded and present them on screen.
/// </summary>
public static async Task <FilmResponse> GetAllFilesInNetwork(int id)
{
try
{
// Call the login api.
var res = await("http://localhost:3000/file/getAll")
.PostUrlEncodedAsync(new { ownerID = id })
.ReceiveString();
FilmResponse filmRes = JsonConvert.DeserializeObject <FilmResponse>(res);
//
return(filmRes);
}
catch
{
Console.WriteLine("Failed to get files");
return(null);
}
}
public async Task <FilmResponse> GetFilms()
{
FilmResponse response = new FilmResponse();
try
{
Debug.WriteLine("Get films");
var requestUrl = string.Format("{0}films/", _baseUrl);
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
var resultString = await client.GetStringAsync(requestUrl);
response = JsonConvert.DeserializeObject <FilmResponse>(resultString);
return(response);
}
}
catch (Exception ex)
{
return(null);
}
return(response);
}
public async Task <IActionResult> UpdateFilm([FromRoute] long id, [FromBody] UpdateFilmRequest request)
{
IActionResult result = null;
await _eventService.Subscribe <ValidationFailedEvent>((failedEvent) =>
{
result = FromFailedValidationResult(failedEvent);
});
await _eventService.Subscribe <FilmUpdatedEvent>((updatedEvent) =>
{
var response = FilmResponse.FromDomainModel(updatedEvent.Film);
result = Ok(response);
});
await _eventService.IssueCommand(new UpdateFilmCommand
{
FilmId = id,
Title = request.Title,
RuntimeInMinutes = request.RuntimeInMinutes
});
return(result);
}
public async Task <IActionResult> GetWatchedFilms(int page = 1, int pageSize = 5)
{
var count = await _filmReader.GetWatchedFilmCount(_currentUserAccessor.CurrentUser.Id);
var records = await _filmReader.GetWatched(_currentUserAccessor.CurrentUser.Id, pageSize, (page - 1) *pageSize);
return(Ok(PagedResponse <FilmResponse> .FromEnumerable(records, record => FilmResponse.FromRecord(record), page, pageSize, count)));
}
