Пример #1
0
 private void Clear_Click(object sender, RoutedEventArgs e)
 {
     Isbn.Clear();
     isbnmsg.Visibility      = Visibility.Visible;
     Name.Content            = "";
     fkTypeCode.Content      = "";
     fkTypeName.Content      = "";
     fkPressName.Content     = "";
     Author.Content          = "";
     unifyNum.Content        = "";
     parallelTitle.Content   = "";
     postIssueNumber.Content = "";
     openBook.Content        = "";
     issnPrice.Content       = "";
     releaseCycle.Content    = "";
     remark.Content          = "";
     periodicalInfo          = new PeriodicalInfo();
     EPC.Clear();
     BookCode.Clear();
     info = new CallNumberInfo();
     CallNumberTxt.Clear();
     callNumbermsg.Visibility = Visibility.Visible;
     PeriodicalCode.Clear();
     PeriodicalMsg.Visibility   = Visibility.Visible;
     sNumber.Content            = "";
     page.Content               = "";
     publicationDateStr.Content = "";
     remarks.Content            = "";
     price.Content              = "";
 }
Пример #2
0
        public void AddBook_RepositoryThrowsException_ThrowsException()
        {
            _repoMock
            .Setup(repo => repo.AddBook(It.IsAny <Book>()))
            .Throws(new DataException("Test data exception!"));

            _dataService = new DataService(_repoMock.Object, _dateProviderMock.Object);

            var isbn = new Isbn("979-3-16-148410-0");

            var exception = Assert.ThrowsException <DataServiceException>(
                () => _dataService.AddBook(isbn, "Title", "Author")
                );

            Assert.IsInstanceOfType(exception.InnerException, typeof(DataException));

            Predicate <Book> validator = e =>
                                         e.Isbn == isbn &&
                                         e.Name == "Title" &&
                                         e.Author == "Author";

            _repoMock.Verify(
                repo => repo.AddBook(Match.Create <Book>(validator)),
                Times.Once()
                );
        }
Пример #3
0
        public void The_Hyphens_In_An_Isbn_Do_Not_Affect_Hashcode()
        {
            var one   = new Isbn("978-0-123456789");
            var other = new Isbn("9780123456789");

            one.GetHashCode().Equals(other.GetHashCode()).Should().BeTrue();
        }
        public int Update(Isbn param, SqlTransaction transaccion)
        {
            string query = " UPDATE Cat_ISBN SET ISBN = @isbn, desc_ver = @descripcion, reimpresion = @reimpresion, reedicion = @reedicion ";

            query = query + " WHERE id_tit_isbn = @idIsbn ; ";
            SqlParameter param1 = new SqlParameter()
            {
                ParameterName = "@isbn", Direction = System.Data.ParameterDirection.Input, SqlDbType = System.Data.SqlDbType.NVarChar, Size = 50, Value = param.ClaveIsbn.Trim()
            };
            SqlParameter param2 = new SqlParameter()
            {
                ParameterName = "@descripcion", Direction = System.Data.ParameterDirection.Input, SqlDbType = System.Data.SqlDbType.NVarChar, IsNullable = true, Value = (String.IsNullOrEmpty(param.DescripcionVersion) ? DBNull.Value : (object)param.DescripcionVersion.Trim())
            };
            SqlParameter param3 = new SqlParameter()
            {
                ParameterName = "@reimpresion", Direction = System.Data.ParameterDirection.Input, SqlDbType = System.Data.SqlDbType.NChar, Size = 10, IsNullable = true, Value = (String.IsNullOrEmpty(param.Reimpresion) ? DBNull.Value : (object)param.Reimpresion.Trim())
            };
            SqlParameter param4 = new SqlParameter()
            {
                ParameterName = "@reedicion", Direction = System.Data.ParameterDirection.Input, SqlDbType = System.Data.SqlDbType.NChar, Size = 10, IsNullable = true, Value = (String.IsNullOrEmpty(param.Reedicion) ? DBNull.Value : (object)param.Reedicion.Trim())
            };
            SqlParameter param5 = new SqlParameter()
            {
                ParameterName = "@idIsbn", Direction = System.Data.ParameterDirection.Input, SqlDbType = System.Data.SqlDbType.NChar, Size = 10, Value = param.IdIsbn.Trim()
            };

            List <SqlParameter> parametros = new List <SqlParameter>()
            {
                param1, param2, param3, param4, param5
            };

            int result = this.Ejecutar(query, CommandType.Text, parametros, transaccion);

            return(result);
        }
Пример #5
0
 /// <summary>
 /// Gets the hash code
 /// </summary>
 /// <returns>Hash code</returns>
 public override int GetHashCode()
 {
     unchecked // Overflow is fine, just wrap
     {
         var hashCode = 41;
         // Suitable nullity checks etc, of course :)
         if (Isbn != null)
         {
             hashCode = hashCode * 59 + Isbn.GetHashCode();
         }
         if (Titulo != null)
         {
             hashCode = hashCode * 59 + Titulo.GetHashCode();
         }
         if (Autor != null)
         {
             hashCode = hashCode * 59 + Autor.GetHashCode();
         }
         if (Genero != null)
         {
             hashCode = hashCode * 59 + Genero.GetHashCode();
         }
         if (Data != null)
         {
             hashCode = hashCode * 59 + Data.GetHashCode();
         }
         if (Preco != null)
         {
             hashCode = hashCode * 59 + Preco.GetHashCode();
         }
         return(hashCode);
     }
 }
Пример #6
0
        public void InvalidIsbnCode13Test(string value)
        {
            var code = Isbn.Create(TypeIsbn.Isbn13, value);

            Assert.True(code.IsFailure);
            Assert.Equal("Invalid ISBN code", code.Error);
        }
Пример #7
0
        public async Task <bool> DeleteOneBookAsync(string isbn, CancellationToken cancellationToken)
        {
            Book model = await _Book.Table.Where(c => c.ISBNs.Where(s => s.Value == isbn) != null).SingleOrDefaultAsync(cancellationToken);

            if (model == null)
            {
                return(false);
            }

            if (model.ISBNs.Count <= 1)
            {
                model.BookIsDeleted = true;
                await _Book.UpdateAsync(model, cancellationToken);

                return(true);
            }
            Isbn _isbn = await _isbnRepository.Table.Where(c => c.Value == isbn).SingleOrDefaultAsync(cancellationToken);

            if (_isbn == null)
            {
                return(false);
            }
            await _isbnRepository.DeleteAsync(_isbn, cancellationToken);

            await _Book.UpdateAsync(model, cancellationToken);

            return(true);
        }
Пример #8
0
        public void ValidIsbnCode13Test(string value)
        {
            var code = Isbn.Create(TypeIsbn.Isbn13, value);

            Assert.True(code.IsSuccess);
            Assert.Equal(code.Value.IsbnCode, value);
        }
Пример #9
0
 public Book(Isbn isbn, string title, string description, uint version)
 {
     Isbn        = isbn;
     Title       = title;
     Description = description;
     Version     = version;
 }
 public static void ValidaIsbn(Isbn isbn, string mensagem)
 {
     if (isbn.EhValido() is false)
     {
         Erros.Add(mensagem);
     }
 }
Пример #11
0
 public Book(string title, string author, DateTimeOffset published, Isbn isbn)
 {
     Title     = title;
     Author    = author;
     Published = published;
     Isbn      = isbn;
 }
Пример #12
0
 private void CheckBookIsbn(Isbn isbn)
 {
     if (!_dataContext.books.ContainsKey(isbn))
     {
         throw new DataNotExistsException();
     }
 }
Пример #13
0
        public Task ExecuteAsync(IConsole console)
        {
            // To make the demo simpler, we will just generate random publish date and ISBN if they were not set
            if (Published == default)
            {
                Published = CreateRandomDate();
            }
            if (Isbn == default)
            {
                Isbn = CreateRandomIsbn();
            }

            if (_libraryService.GetBook(Title) != null)
            {
                throw new CommandException("Book already exists.", 1);
            }

            var book = new Book(Title, Author, Published, Isbn);

            _libraryService.AddBook(book);

            console.Output.WriteLine("Book added.");
            console.RenderBook(book);

            return(Task.CompletedTask);
        }
Пример #14
0
        public DateTime?AplicaFechaMaxima(string isbn)
        {
            char[]   charArray = Isbn.ToLower().ToCharArray();
            int      sum       = 0;
            DateTime fechaMaxima;

            foreach (var item in charArray)
            {
                int number;
                int.TryParse(item.ToString(), out number);
                sum = sum + number;
            }
            if (sum > 30)
            {
                fechaMaxima = DateTime.Now;
                int dias = 0;
                while (dias < 14)
                {
                    if (fechaMaxima.DayOfWeek == DayOfWeek.Sunday)
                    {
                        fechaMaxima = fechaMaxima.AddDays(1);
                    }
                    else
                    {
                        fechaMaxima = fechaMaxima.AddDays(1);
                        dias++;
                    }
                }
                return(fechaMaxima);
            }
            else
            {
                return(null);
            }
        }
Пример #15
0
        public void ToString_With_Invalid_Format_By_Case_Throws_FormatException()
        {
            var    sut    = new Isbn("978-0-123456789");
            Action action = () => sut.ToString("o");

            action.Should().Throw <FormatException>();
        }
Пример #16
0
        public void EditBookDetailsTest()
        {
            var faker           = new Faker();
            var author          = new Author(FullName.Create(faker.Name.FirstName(), faker.Name.LastName()).Value);
            var bookCategory    = BookCategory.Create(CategoryBook.Business, faker.Lorem.Text()).Value;
            var bookDescription = BookDescription
                                  .Create(faker.Lorem.Text(), faker.Date.Random.Number(1, DateTime.Now.Year)).Value;
            var bookIsbn = Isbn.Create(TypeIsbn.Isbn10, "ISBN 1-58182-008-9").Value;
            var book     = new Books(author, bookCategory, bookDescription, bookIsbn);
            var oldId    = book.BookId.Value;

            Assert.NotNull(book);
            var newAuthor          = new Author(FullName.Create(faker.Name.FirstName(), faker.Name.LastName()).Value);
            var newBookCategory    = BookCategory.Create(CategoryBook.Business, faker.Lorem.Text()).Value;
            var newBookDescription = BookDescription
                                     .Create(faker.Lorem.Text(), faker.Date.Random.Number(1, DateTime.Now.Year)).Value;
            var newBookIsbn = Isbn.Create(TypeIsbn.Isbn10, "ISBN 1-55182-008-9").Value;

            book.EditBookDetails(newAuthor, newBookCategory, newBookDescription, newBookIsbn);
            Assert.NotEqual(book.Author.FullName.SureName, author.FullName.Name);
            Assert.NotEqual(book.Author.FullName.SureName, author.FullName.Name);
            Assert.NotEqual(book.BookCategory.CategoryName, bookCategory.CategoryName);
            Assert.NotEqual(book.BookDescription.Title, bookDescription.Title);
            Assert.NotEqual(book.BookDescription.Year, bookDescription.Year);
            Assert.NotEqual(book.Isbn.IsbnCode, bookIsbn.IsbnCode);
            Assert.Equal(oldId, book.BookId.Value);
        }
Пример #17
0
        private bool CheckIsbn(Isbn isbn)
        {
            var check = (from i in _db.Books
                         where i.Isbn == isbn
                         select i);

            return(check.Any());
        }
Пример #18
0
        public List <Book> GetBookByIsbn(Isbn isbn)
        {
            var book = (from books in _db.Books
                        where books.Isbn == isbn
                        select books).ToList();

            return(book);
        }
Пример #19
0
        public void The_Hyphens_In_An_Isbn_Do_Not_Affect_Equality()
        {
            var one   = new Isbn("978-0-123456789");
            var other = new Isbn("9780123456789");

            one.Equals(other).Should().BeTrue();
            (one == other).Should().BeTrue();
        }
Пример #20
0
        public void TestToString(string inputString, IsbnFormat format, string expectedResult)
        {
            var isbn = new Isbn(inputString);

            var actualResult = isbn.ToString(format);

            Assert.AreEqual(expectedResult, actualResult);
        }
        public async Task Delete(Isbn isbn)
        {
            var isbnString = IsbnToString(isbn);

            await _dbContext.DeleteAsync <BookDocument>(isbnString);

            await _bookQueuePublisher.Notify(BookAction.Deleted, isbn);
        }
Пример #22
0
        public void InvalidIsbnCodeTest()
        {
            var code           = Isbn.Create(TypeIsbn.Isbn10, string.Empty);
            var expectedResult = "Missing ISBN type or isbnCode is empty";

            Assert.True(code.IsFailure);
            Assert.Equal(expectedResult, code.Error);
        }
Пример #23
0
        public int CompareTo(Book book)
        {
            if (book == null)
            {
                throw new ArgumentNullException();
            }

            return(Isbn.CompareTo(book.Isbn));
        }
Пример #24
0
        private async void Button_Clicked(object sender, EventArgs e)
        {
            Loading.IsVisible = Loading.IsRunning = true;
            var book = Isbn.GetBook(isbn.Text).Result;

            await connect.InsertAsync(book);

            await Navigation.PopAsync();
        }
        public Livro GerarLivroValido()
        {
            Cpf   cpf   = new Cpf("515.523.840-47");
            Nome  nome  = new Nome("Thiago", "Moreira");
            Autor autor = new Autor(nome, new DateTime(1982, 4, 6), cpf);
            Isbn  isbn  = new Isbn("978-12-345-6789-7");

            return(new Livro("teste", DateTime.Now, isbn, "ficção", autor));
        }
        public Livro GerarLivroInvalido()
        {
            Cpf   cpf   = new Cpf("515.523.840-47");
            Nome  nome  = new Nome("Thiago", "Moreira");
            Autor autor = new Autor(nome, new DateTime(1982, 4, 6), cpf);
            Isbn  isbn  = new Isbn("111-11-111-1111-1");

            return(new Livro("", DateTime.Now, isbn, "", autor));
        }
Пример #27
0
        public void ToString_With_Original_Format()
        {
            var sut = new Isbn("978-0-123456789");

            sut.ToString("O").Should().Be("978-0-123456789");
            sut.ToString("G").Should().Be("978-0-123456789");
            sut.ToString("").Should().Be("978-0-123456789");
            sut.ToString((string)null).Should().Be("978-0-123456789");
        }
        public async Task <BookDto> Handle(GetBookByIsbnQuery query, CancellationToken cancellationToken)
        {
            var storage = await _storageRepository.GetAsync(_storageConfig.DevelopStorageId);

            var isbn = new Isbn(query.Isbn);
            var book = storage.Books.FirstOrDefault(x => x.BookInformation.Isbn.Equals(isbn));

            return(book is null ? null : _mapper.Map <BookDto>(book));
        }
Пример #29
0
        public void TestBookProperties()
        {
            var book      = new Book();
            var publisher = new Publisher("Publisher Test");
            var author1   = new Author("Test Author");

            author1.Id = 2;
            var a = new Author("Test")
            {
                Id = 1
            };
            var author2 = new Author("Author Test")
            {
                Id = 2
            };

            var bookAuthors = new List <BookAuthor>()
            {
                new BookAuthor()
                {
                    Book     = book,
                    BookId   = book.Id,
                    Author   = author1,
                    AuthorId = author1.Id
                },
                new BookAuthor()
                {
                    Book     = book,
                    BookId   = book.Id,
                    Author   = author2,
                    AuthorId = author2.Id
                },
            };
            var isbn           = Isbn.FromValue("9788574591865");
            var synopsis       = "Synopsis";
            var numberOfCopies = 2;

            book.Title           = "Test";
            book.Id              = 3;
            book.Publisher       = publisher;
            book.Authors         = bookAuthors;
            book.Isbn            = isbn;
            book.Synopsis        = synopsis;
            book.PublicationYear = 2002;
            book.NumberOfCopies  = numberOfCopies;

            Assert.IsNotNull(book);
            Assert.AreEqual("Test", book.Title);
            Assert.AreEqual(3, book.Id);
            Assert.AreEqual(2002, book.PublicationYear);
            Assert.AreEqual(publisher, book.Publisher);
            Assert.AreEqual(isbn, book.Isbn);
            Assert.AreEqual(synopsis, book.Synopsis);
            Assert.AreEqual(numberOfCopies, book.NumberOfCopies);
            bookAuthors.AssertListEquals(book.Authors);
        }
Пример #30
0
 public LibraryBook(Isbn isbn, DateTime published, string title, string author = No_Author, int quantity = 0, string content = "not digitalized")
 {
     this.ISBN = isbn;
     this.Title = title;
     this.Author = author;
     this.Quantity = quantity;
     this.Published = published;
     this.Content = content;
     this.Borrowed = 0;
 }
Пример #31
0
 public ShopBook(Isbn isbn, DateTime published, string title, string author, int quantity, string content, double price)
     : base(isbn: isbn, 
           published: published,
           title: title,
           author: author,
           quantity: quantity,
           content: content)
 {
     this.Price = price;
 }
Пример #32
0
        public void TestGetIsbnCheckValueProperties()
        {
            var isbn = Isbn.FromValue("9788574591865");

            isbn.Id = 3;

            Assert.IsNotNull(isbn);
            Assert.AreEqual("9788574591865", isbn.Value);
            Assert.AreEqual(3, isbn.Id);
        }