public AuthenticationActionCreator(ITMDBService tmdbService, IAppStoreContainer storeContainer)
{
TMDBService = tmdbService;
Store = storeContainer.Store;
LoginAction = Store.CreateAsyncActionVoid <Credentials>(async(dispatcher, getState, credentials) =>
{
var state = getState().DiscoverState;
dispatcher(new LoginStarted());
var tokenRequestResponse = await TMDBService.CreateTokenRequest();
if (!tokenRequestResponse.IsSuccessful)
{
dispatcher(new LoginFailedAction
{
StatusMessage = tokenRequestResponse.Data.StatusMessage
});
return;
}
var token = tokenRequestResponse.Data.RequestToken;
var validationResponse = await TMDBService.ValidateToken(credentials.Username, credentials.Password, token);
if (!validationResponse.IsSuccessful)
{
dispatcher(new LoginFailedAction
{
StatusMessage = validationResponse.Data.StatusMessage
});
return;
}
token = validationResponse.Data.RequestToken;
var sessionResponse = await TMDBService.CreateSession(token);
if (!sessionResponse.IsSuccessful)
{
dispatcher(new LoginFailedAction
{
StatusMessage = validationResponse.Data.StatusMessage
});
return;
}
dispatcher(new LoggedInAction
{
SessionId = sessionResponse.Data.SessionId
});
});
}
public SearchActionCreator(ITMDBService tmdbService, IAppStoreContainer storeContainer)
{
TMDBService = tmdbService;
Store = storeContainer.Store;
LoadNextPageAction = Store.CreateAsyncActionVoid <string>(async(dispatcher, getState, query) =>
{
var state = getState().SearchState;
if (state.TotalPages != 0 && state.LastLoadedPage == state.TotalPages && query == state.Query)
{
return;
}
if (state.Query != query || string.IsNullOrEmpty(query))
{
dispatcher(new ResetSearchResults
{
Query = query
});
}
dispatcher(new StartLoadingPage());
state = getState().SearchState;
var response = await TMDBService.Search(query, ++state.LastLoadedPage);
if (response.IsSuccessful)
{
dispatcher(new PageLoaded
{
Page = response.Data.Page,
TotalPages = response.Data.TotalPages,
NewPage = response.Data.Results
});
return;
}
dispatcher(new FailedToLoadPage
{
Exception = response.ErrorException
});
});
}
public LoginPageModel(IAppStoreContainer storeContainer, AuthenticationActionCreator authenticationActionCreator)
{
var store = storeContainer.Store;
store.Subscribe(s =>
{
IsLoggingIn = s.AuthenticationState.IsLoggingIn;
if (s.AuthenticationState.Exception != null)
{
CoreMethods.DisplayAlert("An error occured",
s.AuthenticationState.Exception.Message, "OK");
return;
}
if (!string.IsNullOrEmpty(s.AuthenticationState.SessionId))
{
PopCommand.Execute(null);
}
});
PopCommand = new Command(() =>
{
CoreMethods.PopPageModel(true, true);
});
LoginCommand = new Command(() =>
{
if (string.IsNullOrEmpty(Username) || string.IsNullOrEmpty(Password))
{
CoreMethods.DisplayAlert("An error occured",
"All fields are required", "OK");
return;
}
store.Dispatch(authenticationActionCreator.LoginAction(new Model.Credentials
{
Password = Password,
Username = Username
}));
});
}
public ReviewsPageModel(ReviewActionCreator reviewActionCreator, IAppStoreContainer storeContainer)
{
ReviewActionCreator = reviewActionCreator;
Store = storeContainer.Store;
Store.Subscribe(Reduce);
Store.Dispatch(new StartLoadingReviews());
DismissCommand = new Command(() =>
{
CoreMethods.PopPageModel(true);
});
LoadNextPageCommand = new Command(() =>
{
Store.Dispatch(ReviewActionCreator.LoadReviewsAction);
});
}
public DataActionCreator(ITMDBService tmdbService, IAppStoreContainer storeContainer)
{
TMDBService = tmdbService;
Store = storeContainer.Store;
LoadGenresAction = async(dispatcher, getState) =>
{
var response = await TMDBService.GetGenres();
if (!response.IsSuccessful)
{
dispatcher(new GenresLoaded());
return;
}
dispatcher(new GenresLoaded
{
Genres = response.Data.Genres
});
};
LoadProileAction = async(dispatcher, getState) =>
{
var response = await TMDBService.GetProfile();
dispatcher(new StartLoadingProfile());
if (!response.IsSuccessful)
{
dispatcher(new FailedLoadProfile
{
Exception = new Exception("Failed to load profile")
});
return;
}
dispatcher(new ProfileLoaded
{
Profile = response.Data
});
};
}
public ProfilePageModel(IAppStoreContainer storeContainer, DataActionCreator dataActionCreator)
{
var store = storeContainer.Store;
store.Subscribe(s =>
{
IsAuthenticated = string.IsNullOrEmpty(s.AuthenticationState.SessionId);
IsLoadingProfile = s.DataState.IsLoadingProfile;
Profile = s.DataState.Profile;
ErrorMessage = s.DataState.ProfileLoadError?.Message;
if (IsLoadingProfile)
{
State = ProfilePageState.Loading;
}
else if (s.DataState.ProfileLoadError != null)
{
State = ProfilePageState.Error;
}
else
{
State = ProfilePageState.Loaded;
}
});
LoadProfileCommand = new Command(async() =>
{
if (IsLoadingProfile)
{
return;
}
await store.Dispatch(dataActionCreator.LoadProileAction);
});
LogoutCommand = new Command(() =>
{
store.Dispatch(new LogoutAction());
});
}
public ReviewActionCreator(ITMDBService tmdbService, IAppStoreContainer storeContainer)
{
TMDBService = tmdbService;
Store = storeContainer.Store;
LoadReviewsAction = Store.CreateAsyncActionVoid <int>(async(dispatcher, getState, movieId) =>
{
var state = getState().ReviewsState;
if (state.TotalPages != 0 && state.LastLoadedPage == state.TotalPages && state.MovieId == movieId)
{
return;
}
dispatcher(new StartLoadingReviews
{
MovieId = movieId
});
var response = await TMDBService.GetReviews(movieId, ++state.LastLoadedPage);
if (response.IsSuccessful)
{
dispatcher(new ReviewsLoaded
{
Page = response.Data.Page,
TotalPages = response.Data.TotalPages,
Result = response.Data.Results
});
return;
}
dispatcher(new ReviewsLoadError
{
Exception = new Exception(response.Data.StatusMessage)
});
});
}
public DiscoverActionCreator(ITMDBService tmdbService, IAppStoreContainer storeContainer)
{
TMDBService = tmdbService;
Store = storeContainer.Store;
LoadNextPageAction = async(dispatcher, getState) =>
{
var state = getState().DiscoverState;
if (state.TotalPages != 0 && state.LastLoadedPage == state.TotalPages)
{
return;
}
dispatcher(new StartLoadingDiscoverPage());
var response = await TMDBService.Discover(++state.LastLoadedPage);
if (response.IsSuccessful)
{
dispatcher(new DiscoverPageLoaded
{
Page = response.Data.Page,
TotalPages = response.Data.TotalPages,
NewPage = response.Data.Results
});
return;
}
dispatcher(new FailedToLoadDiscoverPage
{
Exception = response.ErrorException
});
};
}
public FavoriteActionCreator(ITMDBService tmdbService, IAppStoreContainer storeContainer)
{
TMDBService = tmdbService;
Store = storeContainer.Store;
LoadNextPageAction = async(dispatcher, getState) =>
{
var state = getState().FavoriteState;
if (state.TotalPages != 0 && state.LastLoadedPage == state.TotalPages)
{
return;
}
dispatcher(new StartLoadingFavouritePage());
var response = await TMDBService.GetFavoriteMovies(++state.LastLoadedPage);
if (response.IsSuccessful)
{
dispatcher(new FavouritePageLoaded
{
Page = response.Data.Page,
TotalPages = response.Data.TotalPages,
NewPage = response.Data.Results
});
return;
}
dispatcher(new FailedToLoadFavouritePage
{
Exception = new System.Exception(response.Data.StatusMessage)
});
};
}
public MovieDetailActionCreator(ITMDBService tmdbService, IAppStoreContainer storeContainer)
{
TMDBService = tmdbService;
Store = storeContainer.Store;
FavoriteMovieAction = Store.CreateAsyncActionVoid <FavoriteMovieArgs>(async(dispatcher, getState, args) =>
{
dispatcher(new UpdateAccountState
{
IsFavorite = args.IsFavorite
});
var response = await TMDBService.FavoriteMovie(args.IsFavorite, args.MovieId);
if (!response.IsSuccessful)
{
return;
}
dispatcher(new ReloadFavoritesAction());
});
RateMovieAction = Store.CreateAsyncActionVoid <RateMovieArgs>(async(dispatcher, getState, args) =>
{
dispatcher(new UpdateAccountState
{
Rate = args.Rate
});
var response = await TMDBService.RateMovie(args.Rate, args.MovieId);
});
LoadMovieDetailsAction = Store.CreateAsyncActionVoid <int>(async(dispatcher, getState, movieId) =>
{
if (string.IsNullOrEmpty(getState().AuthenticationState.SessionId))
{
return;
}
var cancellationToken = new CancellationTokenSource();
dispatcher(new StartLoadingMovieDetailts
{
MovieId = movieId,
CancellationToken = cancellationToken
});
// null in case of failure, don't really care about excec errors handling here
var loadTask = Task.Factory.StartNew(async() =>
{
var response = await TMDBService.AccountStateForMovie(movieId);
dispatcher(new MovieAccountStateLoaded
{
AccountState = response.Data
});
}, cancellationToken.Token);
try
{
await loadTask;
}
catch (TaskCanceledException)
{
// nothing to do here, user has chonsen another movie
}
});
}
public MovieDetailsPageModel(IAppStoreContainer storeContainer,
MovieDetailActionCreator movieDetailActionCreator,
ReviewActionCreator reviewActionCreator)
{
MovieDetailActionCreator = movieDetailActionCreator;
ReviewActionCreator = reviewActionCreator;
Store = storeContainer.Store;
Store.Subscribe(s =>
{
IsAuthenticated = !string.IsNullOrEmpty(s.AuthenticationState.SessionId);
IsLoadingDetails = s.MovieDetailsState.IsLoading;
if (s.MovieDetailsState.MovieId != Movie.Id || IsLoadingDetails)
{
return;
}
if (s.MovieDetailsState.MovieAccountState == null)
{
// an error occured, can be handled here
return;
}
var accountState = s.MovieDetailsState.MovieAccountState;
IsFavorite = accountState.Favorite;
if (!(accountState.Rated is Dictionary <string, object> rated))
{
return;
}
// workaround, unboxing doesn't work
Rate = int.Parse(rated["value"].ToString());
});
PositiveRateCommand = new Command(async() =>
{
await Store.Dispatch(MovieDetailActionCreator.RateMovieAction(new RateMovieArgs
{
MovieId = Movie.Id,
Rate = 10
}));
});
NegativeRateCommand = new Command(async() =>
{
await Store.Dispatch(MovieDetailActionCreator.RateMovieAction(new RateMovieArgs
{
MovieId = Movie.Id,
Rate = 1
}));
});
FavoriteCommand = new Command(async() =>
{
await Store.Dispatch(MovieDetailActionCreator.FavoriteMovieAction(new FavoriteMovieArgs
{
IsFavorite = !IsFavorite,
MovieId = Movie.Id
}));
});
ReadReviewsCommand = new FreshAwaitCommand(async(parameter, tcs) =>
{
await CoreMethods.PushPageModel <ReviewsPageModel>(Movie, true, true);
tcs.SetResult(true);
await Store.Dispatch(ReviewActionCreator.LoadReviewsAction(Movie.Id));
});
}
