public async override Task LoadAsync(Guid id)
        {
            SelectedItem = await Repository.GetSelectedAsync(id) ?? new Publisher();

            Id = id;

            if (Id != default)
            {
                TabTitle = SelectedItem.Name;
                Name     = SelectedItem.Name;
            }
            else
            {
                this.SwitchEditableStateExecute();
            }

            SetDefaultPublisherLogoIfNoneSet();

            SelectedItem.PropertyChanged += (s, e) =>
            {
                SetChangeTracker();
            };

            void SetDefaultPublisherLogoIfNoneSet()
            {
                if (SelectedItem.LogoPath is null)
                {
                    SelectedItem.LogoPath = FileExplorerService.GetImagePath();
                }
            }
        }
Example #2
0
        public IContainer Bootstrap()
        {
            var builder = new ContainerBuilder();

            builder.RegisterType <EventAggregator>().As <IEventAggregator>().SingleInstance();
            builder.RegisterType <MetroDialogService>().As <IMetroDialogService>();

            builder.RegisterType <MainWindow>().AsSelf();
            builder.RegisterType <MainViewModel>().AsSelf();

            builder.RegisterAssemblyTypes(typeof(MainPageViewModel).Assembly)
            .Where(type => type.Name.EndsWith("ViewModel"))
            .Keyed <ISelectedViewModel>(c => c.Name);

            builder.RegisterAssemblyTypes(typeof(BookDetailViewModel).Assembly)
            .Where(type => type.Name.EndsWith("DetailViewModel"))
            .Keyed <IDetailViewModel>(c => c.Name);

            builder.RegisterType <LookupDataService>().AsImplementedInterfaces()
            .WithParameter("imagePath", FileExplorerService.GetImagePath());

            builder.RegisterAssemblyTypes(typeof(BooksRepository).Assembly)
            .Where(type => type.Name.EndsWith("Repository"))
            .AsImplementedInterfaces();

            var startupDb        = GetStartupDatabase();
            var connectionString = ConnectivityService.GetConnectionString(startupDb);

            builder.RegisterType <BookOrganizerDbContext>().AsSelf().WithParameter("connectionString", connectionString);

            return(builder.Build());
        }
        public async override Task LoadAsync(Guid id)
        {
            try
            {
                var publisher = await domainService.Repository.GetSelectedAsync(id) ?? new Publisher();

                SelectedItem = CreateWrapper(publisher);

                SelectedItem.PropertyChanged += (s, e) =>
                {
                    if (!HasChanges)
                    {
                        HasChanges = domainService.Repository.HasChanges();
                    }
                    if (e.PropertyName == nameof(SelectedItem.HasErrors))
                    {
                        ((DelegateCommand)SaveItemCommand).RaiseCanExecuteChanged();
                    }
                    if (e.PropertyName == nameof(SelectedItem.Name))
                    {
                        TabTitle = SelectedItem.Name;
                    }
                };
                ((DelegateCommand)SaveItemCommand).RaiseCanExecuteChanged();

                Id = id;

                if (Id != default)
                {
                    TabTitle = SelectedItem.Name;
                }
                else
                {
                    this.SwitchEditableStateExecute();
                    SelectedItem.Name = "";
                }

                SetDefaultPublisherLogoIfNoneSet();

                void SetDefaultPublisherLogoIfNoneSet()
                {
                    if (SelectedItem.LogoPath is null)
                    {
                        SelectedItem.LogoPath = FileExplorerService.GetImagePath();
                    }
                }
            }
            catch (Exception ex)
            {
                var dialog = new NotificationViewModel("Exception", ex.Message);
                dialogService.OpenDialog(dialog);

                logger.Error("Message: {Message}\n\n Stack trace: {StackTrace}\n\n", ex.Message, ex.StackTrace);
            }
        }
Example #4
0
        public async override Task LoadAsync(Guid id)
        {
            SelectedItem = await Repository.GetSelectedAsync(id) ?? new Series();

            Id = id;

            if (Id != default)
            {
                TabTitle = SelectedItem.Name;
                Name     = SelectedItem.Name;
            }
            else
            {
                this.SwitchEditableStateExecute();
            }

            await PopulateAllBooksCollection();

            SetDefaultSeriesPictureIfNoneSet();

            SelectedItem.PropertyChanged += (s, e) =>
            {
                SetChangeTracker();
            };

            void SetDefaultSeriesPictureIfNoneSet()
            {
                if (SelectedItem.PicturePath is null)
                {
                    SelectedItem.PicturePath = FileExplorerService.GetImagePath();
                }
            }

            async Task PopulateAllBooksCollection()
            {
                AllBooks.Clear();
                foreach (var item in await GetBookList())
                {
                    AllBooks.Add(item);
                }
            }
        }
Example #5
0
        public async override Task LoadAsync(Guid id)
        {
            try
            {
                var series = await domainService.Repository.GetSelectedAsync(id) ?? new Series();

                SelectedItem = CreateWrapper(series);

                SelectedItem.PropertyChanged += (s, e) =>
                {
                    if (!HasChanges)
                    {
                        HasChanges = domainService.Repository.HasChanges();
                    }
                    if (e.PropertyName == nameof(SelectedItem.HasErrors))
                    {
                        ((DelegateCommand)SaveItemCommand).RaiseCanExecuteChanged();
                    }
                    if (e.PropertyName == nameof(SelectedItem.Name))
                    {
                        TabTitle = SelectedItem.Name;
                    }
                };
                ((DelegateCommand)SaveItemCommand).RaiseCanExecuteChanged();

                Id = id;

                if (Id != default)
                {
                    TabTitle = SelectedItem.Name;
                }
                else
                {
                    this.SwitchEditableStateExecute();
                    SelectedItem.Name = "";
                }

                await PopulateAllBooksCollection();

                SetDefaultSeriesPictureIfNoneSet();

                void SetDefaultSeriesPictureIfNoneSet()
                {
                    if (SelectedItem.PicturePath is null)
                    {
                        SelectedItem.PicturePath = FileExplorerService.GetImagePath();
                    }
                }


                async Task PopulateAllBooksCollection()
                {
                    AllBooks.Clear();
                    foreach (var item in await GetBookList())
                    {
                        AllBooks.Add(item);
                    }
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
                logger.Error("Message: {Message}\n\n Stack trace: {StackTrace}\n\n", ex.Message, ex.StackTrace);
            }
        }
 private async void OnAddPublisherLogoExecute()
 {
     SelectedItem.LogoPath = FileExplorerService.BrowsePicture() ?? SelectedItem.LogoPath;
     await LoadAsync(this.Id);
 }
 private void OnAddPublisherLogoExecute()
 {
     SelectedItem.LogoPath = FileExplorerService.BrowsePicture() ?? SelectedItem.LogoPath;
 }