public RecordViewModel(Record record, IFileSafe fileSafe, IFileIdGenerator fileIdGenerator)
        {
            _fileSafe        = fileSafe;
            _fileIdGenerator = fileIdGenerator;
            Id              = record.Header.Id;
            Name            = record.Header.Name;
            Tags            = record.Header.Tags;
            PasswordRecords = new ObservableCollection <PasswordRecordViewModel>();
            FileRecords     = new ObservableCollection <FileRecordViewModel>();

            PasswordRecords.CollectionChanged += (sender, args) => { IsRecordModified = true; };
            FileRecords.CollectionChanged     += (sender, args) => { IsRecordModified = true; };

            foreach (var passwordRecord in record.PasswordRecords)
            {
                AddNewPasswordRecord(passwordRecord.Name, passwordRecord.Value);
            }

            foreach (var fileRecord in record.FileRecords)
            {
                var fileRecordViewModel = new FileRecordViewModel(FileRecords, _fileSafe, fileRecord.AssociatedRecordId,
                                                                  fileRecord.FileId, () => { IsRecordModified = true; })
                {
                    Name        = fileRecord.Name,
                    Description = fileRecord.Description,
                    Extention   = fileRecord.Extention
                };
                FileRecords.Add(fileRecordViewModel);
            }

            _initialized = true;
            AddNewPasswordRecord(string.Empty, string.Empty);
            IsRecordModified = false;
        }
Пример #2
0
 public S3FileStoreClient(ILogger <S3FileStoreClient> logger, IS3ClientFactory s3ClientFactory, IFileIdGenerator fileIdGenerator, IOptions <FileSystemOption> option)
 {
     _logger          = logger;
     _s3ClientFactory = s3ClientFactory;
     _fileIdGenerator = fileIdGenerator;
     _option          = option.Value;
 }
        public void SetUp()
        {
            _recordIdGenerator = Substitute.For <IRecordIdGenerator>();
            _fileIdGenerator   = Substitute.For <IFileIdGenerator>();
            _recordIdGenerator.GetRecordId().Returns(_uniqueId);

            _safe = Substitute.For <ISafe>();

            _addOperationViewModel = new AddOperationViewModel(() => { _isDiscardActionPerformed = true; }, (x) =>
            {
                _idAtSaveAction = x;
            },
                                                               _recordIdGenerator,
                                                               _fileIdGenerator,
                                                               _safe);
            _saveCommandObserver = _addOperationViewModel.SaveCommand.GetDelegateCommandObserver();
        }
        public RecordAlteringOperationViewModel(ISafe safe, string recordId, IFileIdGenerator fileIdGenerator, Action reloadAction, Action closeAction)
        {
            _safe         = safe;
            _recordId     = recordId;
            _reloadAction = reloadAction;
            _closeAction  = closeAction;
            var record = safe.GetRecord(recordId);

            Record = new RecordViewModel(record, safe, fileIdGenerator);



            SaveCommand           = new DelegateCommand(Save, CanSave);
            DeleteCommand         = new DelegateCommand(Delete);
            DiscardCommand        = new DelegateCommand(Discard);
            GoToSearchCommand     = new DelegateCommand(GoToSearch, () => !Record.IsRecordModified);
            Record.RecordChanged += () => { GoToSearchCommand.RaiseCanExecuteChanged(); };

            Record.PropertyChanged += (a, b) => { SaveCommand.RaiseCanExecuteChanged(); };
        }
Пример #5
0
        public AddOperationViewModel(Action discardAction, Action <string> saveAction, IRecordIdGenerator recordIdGenerator, IFileIdGenerator fileIdGenerator, ISafe safe)
        {
            Record = new RecordViewModel(CreateEmptyRecord(recordIdGenerator.GetRecordId()), safe, fileIdGenerator);
            Record.PropertyChanged += (sender, args) =>
            {
                CanExecuteSaveCommand = !string.IsNullOrWhiteSpace(Record.Name);
            };

            DiscardCommand = new DelegateCommand
                                 (() =>
            {
                safe.ReorganizeFiles(Record.Id);
                discardAction.Invoke();
            }
                                 );

            SaveCommand = new DelegateCommand(() =>
            {
                var record = Record.GetRecord();
                safe.UpsertRecord(record);
                safe.ReorganizeFiles(Record.Id);
                saveAction.Invoke(Record.Id);
            }, () => CanExecuteSaveCommand);
        }
        public void SetUp()
        {
            _id        = "someId";
            _name      = "someName";
            _tagString = "tag1;tag2";

            _passwordRecords = new List <PasswordRecord>()
            {
                new PasswordRecord()
                {
                    Name = "Name1", Value = "Value1"
                },
                new PasswordRecord()
                {
                    Name = "Name2", Value = "Value2"
                },
                new PasswordRecord()
                {
                    Name = "Name3", Value = "Value3"
                },
            };

            _fileRecords = new List <FileRecord>()
            {
                new FileRecord()
                {
                    Name = "Name1", Extention = "pdf", Description = "Description1", AssociatedRecordId = _id, FileId = "F1"
                },
                new FileRecord()
                {
                    Name = "Name2", Extention = "txt", Description = "Description2", AssociatedRecordId = _id, FileId = "F2"
                },
                new FileRecord()
                {
                    Name = "Name3", Extention = "xlsx", Description = "Description3", AssociatedRecordId = _id, FileId = "F3"
                },
            };

            var record = new Record
            {
                Header          = new RecordHeader(),
                FileRecords     = new List <FileRecord>(),
                PasswordRecords = new List <PasswordRecord>()
            };

            record.Header.Id   = _id;
            record.Header.Name = _name;
            record.Header.Tags = _tagString;
            record.PasswordRecords.AddRange(_passwordRecords);
            record.FileRecords.AddRange(_fileRecords);

            _fileSafe = Substitute.For <IFileSafe>();

            _fileIdGenerator = Substitute.For <IFileIdGenerator>();

            _recordViewModel                = new RecordViewModel(record, _fileSafe, _fileIdGenerator);
            _recordModificationStatus       = false;
            _recordViewModel.RecordChanged += () =>
            {
                _recordModificationStatus = _recordViewModel.IsRecordModified;
            };
        }