public RegionOnPopupWindowContentControlViewModel( Model model )
        {
            Model = model;

            ShowConfirmationCommand = new DelegateCommand( OnShowConfirmation );
            ConfirmationRequest = new InteractionRequest<INotification>();
        }

 public ReferenceDataAddViewModel(IEventAggregator eventAggregator, IReferenceDataService entityService)
 {
     this.eventAggregator = eventAggregator;
     this.confirmationFromViewModelInteractionRequest = new InteractionRequest<Confirmation>();
     this.entityService = entityService;
     this.ReferenceData = new ReferenceDataViewModel(null, null, this.eventAggregator);
 }

        public MultipleReversalReAllocationViewModel(int batchID, int reason, List<DishonourReversalReceiptSummary> receipts)
        {
            receiptBatchID = batchID;
            reasonSelected = reason;
            reversalReceipts = receipts;

            try
            {
                SetReceiptDefaults(receiptBatchID);

                Save = new DelegateCommand<string>(OnSave);
                ReAllocationSearch = new DelegateCommand(OnReAllocationSearch);

                Popup = new InteractionRequest<PopupWindow>();
                UIConfirmation = new InteractionRequest<ConfirmationWindowViewModel>();
                IconFileName = "ReAllocation.jpg";
            }
            catch (Exception ex)
            {
                ExceptionLogger.WriteLog(ex);
                ShowErrorMessage("Error occurred while initializing Reversal Receipts Re-Allocation Screen", "Receipt Reallocation - Error");
            }
            finally
            {
                IsBusy = false;
            }
        }

        public CategoriesViewModel(Client client)
        {
            _client = client;

            Categories = new ObservableCollection<Category>(
                _client.Context.Categories.ToList());

            AddNewCategoryRequest = new InteractionRequest<IConfirmation>();
            AddCategoryCommand = new DelegateCommand(() =>
                AddNewCategoryRequest.Raise(
                    new Confirmation()
                    {
                        Title = "Nowa kategoria",
                        Content = new System.Windows.Controls.TextBox()
                        {
                            VerticalAlignment = System.Windows.VerticalAlignment.Top
                        }
                    },
                    AddCategory));
            ConfirmDeleteCategoryRequest = new InteractionRequest<IConfirmation>();
            DeleteCategoryCommand = new DelegateCommand(() =>
                ConfirmDeleteCategoryRequest.Raise(
                    new Confirmation()
                    {
                        Title = "Potwierdź",
                        Content = "Czy na pewno usunąć wybraną kategorię?"
                    },
                    DeleteCategory)
                , CanDeleteCategory);
        }

        public DishonourReversalExcelImportViewModel(ReceiptBatchType receiptBatchType, int receiptBatchId)
        {
            batchType = receiptBatchType;
            receiptBatchID = receiptBatchId;

            reasonCodes = DishonourReversalFunctions.GetReasonCodes(batchType);

            Browse = new DelegateCommand(OnBrowse);
            Upload = new DelegateCommand(OnUpload);
            Save = new DelegateCommand(OnSave);
            Delete = new DelegateCommand(OnDelete);
            OpenExcelTemplate = new DelegateCommand(OnOpenExcelTemplate);

            Title = batchType.ToString() + " Receipts Excel Import";
            IconFileName = "Excel.jpg";
            UIConfirmation = new InteractionRequest<ConfirmationWindowViewModel>();

            if (batchType == ReceiptBatchType.Dishonour)
            {
                excelTemplateFileName = "DishonourReceiptImportTemplate.xlsx";
            }
            else
            {
                excelTemplateFileName = "ReversalReceiptImportTemplate.xlsx";
            }
        }

		private void Initialize()
		{
			CancelCommand = new DelegateCommand<object>(x => Cancel(), x => !_cancelled || IsValid);
			CancelConfirmRequest = new InteractionRequest<Confirmation>();

			InitStepsAndViewTitle();
		}

        public ChatViewModel(IChatService chatService)
        {
            this.contacts = new ObservableCollection<Contact>();
            this.contactsView = new CollectionView(this.contacts);
            this.sendMessageRequest = new InteractionRequest<SendMessageViewModel>();
            this.showReceivedMessageRequest = new InteractionRequest<ReceivedMessage>();
            this.showDetailsCommand = new DelegateCommand<bool?>(this.ExecuteShowDetails, this.CanExecuteShowDetails);

            this.contactsView.CurrentChanged += this.OnCurrentContactChanged;

            this.chatService = chatService;
            this.chatService.Connected = true;
            this.chatService.ConnectionStatusChanged += (s, e) => this.OnPropertyChanged(() => this.ConnectionStatus);
            this.chatService.MessageReceived += this.OnMessageReceived;

            this.chatService.GetContacts(
                result =>
                {
                    if (result.Error == null)
                    {
                        foreach (var item in result.Result)
                        {
                            this.contacts.Add(item);
                        }
                    }
                });
        }

        public RegionWithPopupWindowActionExtensionsViewModel( Model model )
        {
            Model = model;

            ShowConfirmationCommand = new DelegateCommand( OnShowConfirmation );
            ConfirmationRequest = new InteractionRequest<INotification>();
        }

        public ComplexCustomViewViewModel( Model model )
        {
            Model = model;

            ShowConfirmationCommand = new DelegateCommand( OnShowConfirmation );
            ConfirmationRequest = new InteractionRequest<INotification>();
        }

        public TaskCollectionsViewModel(
            INavigationService navigationService,
            IRtmServiceClient rtmServiceClient,
            ITaskStoreLocator taskStoreLocator,
            IListStoreLocator listStoreLocator,
            ILocationStoreLocator locationStoreLocator,
            ISynchronizationService synchronizationService)
            : base(navigationService)
        {
            this._rtmServiceClient = rtmServiceClient;
            this._taskStoreLocator = taskStoreLocator;
            this._listStoreLocator = listStoreLocator;
            this._locationStoreLocator = locationStoreLocator;
            this._synchronizationService = synchronizationService;

            this.submitErrorInteractionRequest = new InteractionRequest<Notification>();
            this.submitNotificationInteractionRequest = new InteractionRequest<Notification>();

            this.StartSyncCommand = new DelegateCommand(
                () => { this.StartSync(); },
                () => !this.IsSyncing && !this.SettingAreNotConfigured);

            this.ViewTaskCollectionCommand = new DelegateCommand(
                () => { this.NavigationService.Navigate(new Uri("/Views/TaskCollectionView.xaml", UriKind.Relative)); },
                () => !this.IsSyncing);

            this.AppSettingsCommand = new DelegateCommand(
                () => { this.NavigationService.Navigate(new Uri("/Views/AppSettingsView.xaml", UriKind.Relative)); },
                () => !this.IsSyncing);

            this.IsBeingActivated();
        }

        public AddReceiptsViewModel(int receiptbatchType, int batchID)
        {
            BatchType batch;

            try
            {
                batchType = receiptbatchType;
                ReceiptBatch = ReceiptBatchFunctions.Get(batchID);
                ReceiptDate = ReceiptBatch.ReceiptDate;

                Save = new DelegateCommand(OnSave);
                SearchCommand = new DelegateCommand(OnSearch);
                ReceiptSelectedCommand = new DelegateCommand<ObservableCollection<object>>(ReceiptSelected);

                UIConfirmation = new InteractionRequest<ConfirmationWindowViewModel>();
                Popup = new InteractionRequest<PopupWindow>();
                SelectList = BatchTypeFunctions.GetSelectList(batchType);
                SetReceiptBatchDefaults();

                IconFileName = "AddMultiple.jpg";
            }
            catch (Exception ex)
            {
                ExceptionLogger.WriteLog(ex);
                ShowErrorMessage("Error encountered while initializing Add Receipts.", "Add Receipts - Error");
            }
            finally
            {
                IsBusy = false;
            }
        }

		public PropertyEditViewModel(
			IViewModelsFactory<IPickAssetViewModel> pickAssetVmFactory,
			IViewModelsFactory<ISearchCategoryViewModel> searchCategoryVmFactory,
			DynamicContentItemProperty item)
		{
			_pickAssetVmFactory = pickAssetVmFactory;
			_searchCategoryVmFactory = searchCategoryVmFactory;

			InnerItem = item;

			var itemValueType = (PropertyValueType)InnerItem.ValueType;
			IsShortStringValue = itemValueType == PropertyValueType.ShortString;
			IsLongStringValue = itemValueType == PropertyValueType.LongString;
			IsDecimalValue = itemValueType == PropertyValueType.Decimal;
			IsIntegerValue = itemValueType == PropertyValueType.Integer;
			IsBooleanValue = itemValueType == PropertyValueType.Boolean;
			IsDateTimeValue = itemValueType == PropertyValueType.DateTime;
			IsAssetValue = itemValueType == PropertyValueType.Image;
			IsCategoryValue = itemValueType == PropertyValueType.Category;

			if (IsAssetValue)
				SelectedAssetDisplayName = InnerItem.LongTextValue;

			if (IsCategoryValue)
				SelectedCategoryName = InnerItem.Alias;

			AssetPickCommand = new DelegateCommand(RaiseItemPickInteractionRequest);
			CategoryPickCommand = new DelegateCommand(RaiseCategoryPickInteractionRequest);
			CommonConfirmRequest = new InteractionRequest<Confirmation>();
		}

        public FilesViewModel(IFilesRepository filesRepository, IAuthStore authStore, IProductsRepository productsRepository, 
            Func<CreateFileViewModel> createFactory, Func<EditFileViewModel> editFactory)
        {
            this.filesRepository = filesRepository;
            this.productsRepository = productsRepository;
            this.createFactory = createFactory;
            this.editFactory = editFactory;

            var token = authStore.LoadToken();
            if (token != null)
            {
                IsEditor = token.IsEditor();
                IsAdmin = token.IsAdmin();
            }

            cvs = new CollectionViewSource();
            items = new ObservableCollection<FileDescription>();
            cvs.Source = items;
            cvs.SortDescriptions.Add(new SortDescription("Name", ListSortDirection.Ascending));
            cvs.SortDescriptions.Add(new SortDescription("Id", ListSortDirection.Ascending));

            editRequest = new InteractionRequest<IConfirmation>();
            BrowseCommand = new DelegateCommand(Browse);
            EditCommand = new DelegateCommand<FileDescription>(Edit);

            deleteCommand = new DelegateCommand(PromtDelete, HasSelectedItems);
            deleteRequest = new InteractionRequest<Confirmation>();
        }

 public BrokerAddViewModel(IEventAggregator eventAggregator, IMdmService entityService)
 {
     this.eventAggregator = eventAggregator;
     this.confirmationFromViewModelInteractionRequest = new InteractionRequest<Confirmation>();
     this.entityService = entityService;
     this.Broker = new BrokerViewModel(this.eventAggregator);
 }

        public EditViewModel( IDataService dataService )
        {
            _dataService = dataService;

            // Initialize the Navigation Interaction Request .
            navigationInteractionRequest = new InteractionRequest<Confirmation>();
        }

        public PropertyViewModel(IViewModelsFactory<IPropertyValueViewModel> propertyValueVmFactory, IViewModelsFactory<IPropertyAttributeViewModel> attributeVmFactory, ICatalogEntityFactory entityFactory, Property item, catalogModel.Catalog parentCatalog, IRepositoryFactory<ICatalogRepository> repositoryFactory, ObservableCollection<Property> properties)
        {
            InnerItem = item;
            _propertyValueVmFactory = propertyValueVmFactory;
            _attributeVmFactory = attributeVmFactory;
            _entityFactory = entityFactory;
            _properties = properties;
            ParentCatalog = parentCatalog;
            // _repositoryFactory = repositoryFactory;

            ValueAddCommand = new DelegateCommand(RaiseValueAddInteractionRequest);
            ValueEditCommand = new DelegateCommand<PropertyValueBase>(RaiseValueEditInteractionRequest, x => x != null);
            ValueDeleteCommand = new DelegateCommand<PropertyValueBase>(RaiseValueDeleteInteractionRequest, x => x != null);

            AttributeAddCommand = new DelegateCommand(RaiseAttributeAddInteractionRequest);
            AttributeEditCommand = new DelegateCommand<PropertyAttribute>(RaiseAttributeEditInteractionRequest, x => x != null);
            AttributeDeleteCommand = new DelegateCommand<PropertyAttribute>(RaiseAttributeDeleteInteractionRequest, x => x != null);


            CommonConfirmRequest = new InteractionRequest<Confirmation>();

            var allValueTypes = (PropertyValueType[])Enum.GetValues(typeof(PropertyValueType));
            PropertyTypes = new List<PropertyValueType>(allValueTypes);
            PropertyTypes.Sort((x, y) => x.ToString().CompareTo(y.ToString()));
        }

        public PropertyValueBaseViewModel(IViewModelsFactory<IPickAssetViewModel> vmFactory, PropertyAndPropertyValueBase item, string locale)
        {
            InnerItem = item;
            _vmFactory = vmFactory;
            _locale = locale;

            if (InnerItem.IsEnum)
            {
                if (InnerItem.IsMultiValue)
                {
                    foreach (var value in InnerItem.Values)
                    {
                        var propertyValue = InnerItem.Property.PropertyValues.FirstOrDefault(x => x.PropertyValueId == value.KeyValue);
                        if (propertyValue != null)
                        {
                            value.BooleanValue = propertyValue.BooleanValue;
                            value.DateTimeValue = propertyValue.DateTimeValue;
                            value.DecimalValue = propertyValue.DecimalValue;
                            value.IntegerValue = propertyValue.IntegerValue;
                            value.LongTextValue = propertyValue.LongTextValue;
                            value.ShortTextValue = propertyValue.ShortTextValue;
                            value.KeyValue = propertyValue.PropertyValueId;
                        }
                    }
                }

                var defaultView = CollectionViewSource.GetDefaultView(InnerItem.Property.PropertyValues);
                defaultView.Filter = FilterPropertyValues;
            }

            SetVisibility();
            AssetPickCommand = new DelegateCommand(RaiseAssetPickInteractionRequest);
            AssetRemoveCommand = new DelegateCommand(RaiseAssetRemoveInteractionRequest);
            CommonConfirmRequest = new InteractionRequest<Confirmation>();
        }

        public MainViewModel()
        {
            LaunchPopupCommand = new DelegateCommand(ExecuteLaunchPopupCommand, CanExecuteLaunchPopupCommand);
            LaunchPopupRequest = new InteractionRequest<Confirmation>();

            
        }

		public BuildSettingsViewModel(IBuildSettingsRepository repository)
		{
			_repository = repository;

			ItemRebuildCommand = new DelegateCommand<BuildSettings>(RaiseItemRebuildInteractionRequest, x => x != null);
			CommonConfirmRequest = new InteractionRequest<Confirmation>();
		}

        public LoadProjectService(IProjectSerializer ProjectSerializer, ProjectViewModelFactory ProjectViewModelFactory)
        {
            _projectSerializer = ProjectSerializer;
            _projectViewModelFactory = ProjectViewModelFactory;

            OpenFileRequest = new InteractionRequest<OpenFileInteractionContext>();
        }