public PurchaseViewModel(int cakeId, ICakeModelService cakeModelService = null, IShoppingBagModelService shoppingBagModelService = null)
{
_cakeModelService = cakeModelService ?? Locator.Current.GetService <ICakeModelService>();
_shoppingBagModelService = shoppingBagModelService ?? Locator.Current.GetService <IShoppingBagModelService>();
var shoppingBag = _shoppingBagModelService
.ShoppingBag
.Connect()
.SubscribeOn(RxApp.TaskpoolScheduler)
.Transform(TransformToListItem)
.Publish();
shoppingBag
.Bind(out _shoppingBag)
.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe()
.DisposeWith(CompositeDisposable);
shoppingBag.Connect();
RemoveItemFunc = new Func <int, Task>(async cId =>
{
var cakeOptional = _cakeModelService.Cakes.Lookup(cId);
if (cakeOptional.HasValue)
{
_shoppingBagModelService.RemoveFromShoppingBag(cakeOptional.Value);
}
});
Prepare(cakeId);
}
public BakerProfileViewModel(
string bakerId,
IScreen hostScreen = null,
ICakeModelService cakeModelService = null,
IAppUserModelService appUserModelService = null,
IBakerModelService bakerModelService = null,
IUserApiService userApiService = null,
ILogger logger = null,
IMapper mapper = null) : base(hostScreen)
{
_cakeModelService = cakeModelService;
_appUserModelService = appUserModelService;
_bakerModelService = bakerModelService;
_userApiService = userApiService;
_logger = logger;
_mapper = mapper;
_bakerIdSubject = new Subject <string>();
StartChatCommand = ReactiveCommand.CreateFromTask(GoToChat);
PrepareCommand = ReactiveCommand.CreateFromTask(async b => await Prepare(bakerId));
Observable.Return(Unit.Default)
.InvokeCommand(PrepareCommand);
PrepareCommand.Subscribe();
}
public CakeDetailViewModel(
int bakerId,
ICakeModelService cakeModelService = null,
IAppUserModelService appUserModelService = null,
IScreen hostScreen = null, ILogger logger = null) : base(hostScreen)
{
_cakeModelService = cakeModelService;
_appUserModelService = appUserModelService;
_logger = logger;
_cakeIdSubject = new Subject <int>();
ToggleFavoriteCommand = ReactiveCommand.CreateFromTask(ToggleFavorite);
InitiateChatCommand = ReactiveCommand.CreateFromTask <int>(InitiateChat);
OrderCakeCommand = ReactiveCommand.CreateFromTask(OrderCake);
GoToBakerCommand = ReactiveCommand.CreateFromTask <string>(GoToBaker);
ToggleFavoriteFunc = new Func <int, Task>(async id =>
{
var isFavorite = _appUserModelService.FavouriteCakes.Lookup(id).HasValue;
if (isFavorite)
{
_appUserModelService.FavouriteCakes.Edit(l => l.RemoveKey(id));
}
else
{
var cake = _cakeModelService.Cakes.Lookup(id);
if (cake.HasValue)
{
_appUserModelService.FavouriteCakes.Edit(l => l.AddOrUpdate(cake.Value));
}
}
await _cakeModelService.UpdateFavourite(_appUserModelService.UserId, id);
});
Prepare(bakerId);
}
public FavoritesViewModel(IScreen hostScreen = null, IAppUserModelService appUserModelService = null, ICakeModelService cakeModelService = null, ILogger logger = null) : base(hostScreen)
{
_hostScreen = hostScreen;
_logger = logger ?? Locator.Current.GetService <ILogger>();
_cakeModelService = cakeModelService ?? Locator.Current.GetService <ICakeModelService>();
_appUserModelService = appUserModelService ?? Locator.Current.GetService <IAppUserModelService>();
_cd = new CompositeDisposable();
var favoriteCakes = _appUserModelService
.FavouriteCakes
.Connect()
.SubscribeOn(RxApp.TaskpoolScheduler)
.Transform(TransformToListItem)
.Publish();
favoriteCakes
.Bind(out _favoriteCakes)
.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe()
.DisposeWith(_cd);
favoriteCakes
.MergeMany(vm => vm.GoToDetailsCommand)
.Subscribe(async c => await GoToDetails(c))
.DisposeWith(_cd);
favoriteCakes
.MergeMany(vm => vm.GoToBakerCommand)
.Subscribe(async c => await GoToBaker(c))
.DisposeWith(_cd);
favoriteCakes
.MergeMany(vm => vm.ToggleFavoriteCommand)
.Subscribe(async c => await ToggleFavorite(c))
.DisposeWith(_cd);
favoriteCakes.Connect();
ToggleFavoriteFunc = new Func <int, Task>(async id =>
{
var isFavorite = _appUserModelService.FavouriteCakes.Lookup(id).HasValue;
if (isFavorite)
{
_appUserModelService.FavouriteCakes.Edit(l => l.RemoveKey(id));
}
else
{
var cake = _cakeModelService.Cakes.Lookup(id);
if (cake.HasValue)
{
_appUserModelService.FavouriteCakes.Edit(l => l.AddOrUpdate(cake.Value));
}
}
await _cakeModelService.UpdateFavourite(_appUserModelService.UserId, id);
});
}
public SearchViewModel(
IScreen hostScreen = null,
ICakeModelService cakeModelService = null,
IAppUserModelService appUserModelService = null,
IDialogService dialogService = null,
IUserDialogs userDialogs = null,
ILogger logger = null) : base(hostScreen)
{
try
{
_cakeModelService = cakeModelService ?? Locator.Current.GetService <ICakeModelService>();
_appUserModelService = appUserModelService ?? Locator.Current.GetService <IAppUserModelService>();
_dialogService = dialogService ?? Locator.Current.GetService <IDialogService>();
_userDialogs = userDialogs ?? Locator.Current.GetService <IUserDialogs>();
_logger = logger ?? Locator.Current.GetService <ILogger>();
_cd = new CompositeDisposable();
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
var searchFilter = this.ObservableForProperty(vm => vm.Query)
.Value()
.StartWith("")
.DistinctUntilChanged()
.Throttle(TimeSpan.FromMilliseconds(400))
.Select(SearchPredicate);
var cakeTypeFilter = this.ObservableForProperty(vm => vm.CakeTypeFilter)
.Value()
.StartWith(CakeType.None)
.DistinctUntilChanged()
.Select(CakeTypePredicate);
var nearbyCakes = _cakeModelService
.Cakes
.Connect()
.SubscribeOn(RxApp.TaskpoolScheduler)
.Transform(TransformToListItem)
.Publish();
nearbyCakes
.Bind(out _popularSearches)
.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe()
.DisposeWith(_cd);
nearbyCakes
.Filter(searchFilter)
.Filter(cakeTypeFilter)
.Bind(out _searchResults)
.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe()
.DisposeWith(_cd);
nearbyCakes
.MergeMany(vm => vm.GoToDetailsCommand)
.Subscribe(async c => await GoToDetails(c))
.DisposeWith(_cd);
nearbyCakes
.MergeMany(vm => vm.GoToBakerCommand)
.Subscribe(async c => await GoToBaker(c))
.DisposeWith(_cd);
nearbyCakes
.MergeMany(vm => vm.ToggleFavoriteCommand)
.Subscribe(async c => await ToggleFavorite(c))
.DisposeWith(_cd);
nearbyCakes.Connect();
FilterByTypeCommand = ReactiveCommand.Create(FilterByType);
var cakeTypeOptions = Enum.GetNames(typeof(CakeType)).Select(cakeType => new ActionSheetOption(cakeType, () => SetCakeType((CakeType)Enum.Parse(typeof(CakeType), cakeType)))).ToList();
_sheetConfig = new ActionSheetConfig
{
Title = "Kaketype",
UseBottomSheet = true,
Options = cakeTypeOptions
};
}
