public virtual IList <BookVersion> SearchByAuthorAndBookType(string query, BookTypeEnum bookType)
{
Book bookAlias = null;
BookVersion bookVersionAlias = null;
BookType bookTypeAlias = null;
Category categoryAlias = null;
Author authorAlias = null;
using (var session = GetSession())
{
var bookIds = QueryOver.Of(() => bookVersionAlias)
.JoinAlias(() => bookVersionAlias.Categories, () => categoryAlias, JoinType.InnerJoin)
.JoinAlias(() => categoryAlias.BookType, () => bookTypeAlias, JoinType.InnerJoin)
.JoinAlias(() => bookVersionAlias.Book, () => bookAlias, JoinType.InnerJoin)
.JoinAlias(() => bookVersionAlias.Authors, () => authorAlias, JoinType.InnerJoin)
.Select(x => x.Id)
.Where(() => bookTypeAlias.Type == bookType && bookVersionAlias.Id == bookAlias.LastVersion.Id)
.AndRestrictionOn(() => authorAlias.Name).IsLike(query, MatchMode.Anywhere);
var bookVersions = session.QueryOver(() => bookVersionAlias)
.Fetch(x => x.Book).Eager
.Fetch(x => x.Authors).Eager
.WithSubquery
.WhereProperty(x => x.Id)
.In(bookIds)
.TransformUsing(Transformers.DistinctRootEntity)
.List();
return(bookVersions);
}
}
public virtual IList <BookVersion> FindBookVersionsByTypeWithCategories(BookTypeEnum bookType)
{
Book bookAlias = null;
BookVersion bookVersionAlias = null;
BookType bookTypeAlias = null;
Category categoryAlias = null;
using (var session = GetSession())
{
var bookVersions =
session.QueryOver(() => bookVersionAlias)
.JoinAlias(() => bookVersionAlias.Categories, () => categoryAlias)
.JoinAlias(() => categoryAlias.BookType, () => bookTypeAlias)
.JoinAlias(() => bookVersionAlias.Book, () => bookAlias)
.Where(() => bookTypeAlias.Type == bookType && bookVersionAlias.Id == bookAlias.LastVersion.Id)
.OrderBy(() => bookVersionAlias.Title).Asc
.TransformUsing(Transformers.DistinctRootEntity)
.Future <BookVersion>();
session.QueryOver(() => bookVersionAlias)
.JoinAlias(x => x.Book, () => bookAlias)
.Where(() => bookVersionAlias.Id == bookAlias.LastVersion.Id)
.Fetch(x => x.Categories).Eager
.Future <BookVersion>();
return(bookVersions.ToList());
}
}
public virtual IList <string> GetTermsByBookType(string query, BookTypeEnum bookType, IList <long> bookIdList, int recordCount)
{
using (var session = GetSession())
{
Book bookAlias = null;
BookVersion bookVersionAlias = null;
Category categoryAlias = null;
BookType bookTypeAlias = null;
BookPage pageAlias = null;
Term termAlias = null;
var dbQuery = session.QueryOver(() => bookAlias)
.JoinQueryOver(x => x.LastVersion, () => bookVersionAlias)
.JoinQueryOver(x => x.Categories, () => categoryAlias)
.JoinQueryOver(x => categoryAlias.BookType, () => bookTypeAlias)
.JoinQueryOver(x => bookVersionAlias.BookPages, () => pageAlias)
.JoinQueryOver(x => pageAlias.Terms, () => termAlias)
.Select(Projections.Distinct(Projections.Property(() => termAlias.Text)))
.Where(x => bookTypeAlias.Type == bookType)
.AndRestrictionOn(() => termAlias.Text).IsInsensitiveLike(query);
if (bookIdList != null)
{
dbQuery.AndRestrictionOn(() => bookAlias.Id).IsInG(bookIdList);
}
return(dbQuery
.Take(recordCount)
.List <string>());
}
}
public virtual IList <long> GetProjectIds(BookTypeEnum bookType, int userId, ProjectTypeEnum projectType, IList <long> projectIds,
IList <int> categoryIds)
{
Project projectAlias = null;
BookType bookTypeAlias = null;
Category categoryAlias = null;
Permission permissionAlias = null;
UserGroup userGroupAlias = null;
User userAlias = null;
var query = GetSession().QueryOver <Snapshot>()
.JoinAlias(x => x.Project, () => projectAlias)
.JoinAlias(x => x.BookTypes, () => bookTypeAlias)
.JoinAlias(() => projectAlias.Categories, () => categoryAlias, JoinType.LeftOuterJoin)
.JoinAlias(() => projectAlias.Permissions, () => permissionAlias)
.JoinAlias(() => permissionAlias.UserGroup, () => userGroupAlias)
.JoinAlias(() => userGroupAlias.Users, () => userAlias)
.And(() => bookTypeAlias.Type == bookType && userAlias.Id == userId && projectAlias.ProjectType == projectType && projectAlias.IsRemoved == false)
.And(BitwiseExpression.On(() => permissionAlias.Flags).HasBit(PermissionFlag.ShowPublished))
.Select(Projections.Distinct(Projections.Property(() => projectAlias.Id)));
if (projectIds != null && categoryIds != null)
{
query = query.Where(Restrictions.Or(
Restrictions.InG(Projections.Property(() => projectAlias.Id), projectIds),
Restrictions.InG(Projections.Property(() => categoryAlias.Id), categoryIds)
));
}
return(query.List <long>());
}
public virtual IList <string> GetLastTitlesByBookType(int recordCount, BookTypeEnum bookType, IList <long> bookIdList)
{
using (var session = GetSession())
{
Book bookAlias = null;
BookVersion bookVersionAlias = null;
Category categoryAlias = null;
BookType bookTypeAlias = null;
var query = session.QueryOver(() => bookAlias)
.JoinQueryOver(x => x.LastVersion, () => bookVersionAlias)
.JoinQueryOver(x => x.Categories, () => categoryAlias)
.JoinQueryOver(x => categoryAlias.BookType, () => bookTypeAlias)
.Where(x => bookTypeAlias.Type == bookType)
.Select(Projections.Distinct(Projections.Property(() => bookVersionAlias.Title)));
if (bookIdList != null)
{
query.AndRestrictionOn(() => bookAlias.Id).IsInG(bookIdList);
}
return(query
.Take(recordCount)
.List <string>());
}
}
public static int?BookTypeConvert(BookTypeEnum booktype)
{
switch (booktype)
{
case BookTypeEnum.Book:
return(0);
case BookTypeEnum.Paper:
return(1);
case BookTypeEnum.Doc:
return(2);
case BookTypeEnum.Post:
return(3);
case BookTypeEnum.Magzine:
return(4);
case BookTypeEnum.CheetSheet:
return(5);
default:
return(null);
}
}
public TBook(string name, string pathname, string rootFolder, BookTypeEnum type)
: this()
{
Name = name;
Pathname = pathname;
Category = GetGroupName(rootFolder, pathname);
BookType = type;
}
public virtual int GetFavoriteQueriesCount(long?labelId, BookTypeEnum bookTypeEnum, QueryTypeEnum queryTypeEnum, string filterByTitle, int userId)
{
using (var session = GetSession())
{
var query = CreateFavoriteQueriesQuery(session, labelId, bookTypeEnum, queryTypeEnum, filterByTitle, userId);
return(query.RowCount());
}
}
public virtual BookType FindBookTypeByType(BookTypeEnum bookTypeEnum)
{
using (var session = GetSession())
{
return(session.QueryOver <BookType>()
.Where(x => x.Type == bookTypeEnum)
.SingleOrDefault());
}
}
public BaseBook Create(BookTypeEnum type)
{
switch (type)
{
case BookTypeEnum.NOVEL: return(_novel);
default: throw new ArgumentException("无法识别的type");
}
}
private void SetSelectedBookType(BookTypeEnum type)
{
List <Book> books = GetSelectedBook();
foreach (Book book in books)
{
BookHelper.SetBookType(book, type);
}
JianLiLinq.Default.DB.SubmitChanges();
}
public virtual BookType GetBookType(BookTypeEnum bookType)
{
using (var session = GetSession())
{
var result = session.QueryOver <BookType>()
.Where(x => x.Type == bookType)
.SingleOrDefault();
return(result);
}
}
public CreateSnapshotWork(ProjectRepository projectRepository, ResourceRepository resourceRepository, long projectId, int userId, IList <long> resourceVersionIds,
string comment, IList <BookTypeEnum> bookTypes, BookTypeEnum defaultBookType, IFulltextStorage fulltextStorage) : base(projectRepository)
{
m_projectRepository = projectRepository;
m_resourceRepository = resourceRepository;
m_projectId = projectId;
m_userId = userId;
m_resourceVersionIds = resourceVersionIds;
m_comment = comment;
m_bookTypes = bookTypes;
m_defaultBookType = defaultBookType;
m_fulltextStorage = fulltextStorage;
}
private void FillSubcategories(BookTypeEnum bookType, Dictionary <string, BookTypeEnum> xmlIdToBookType,
List <CategoryData> categoryDataList)
{
foreach (var categoryData in categoryDataList)
{
xmlIdToBookType.Add(categoryData.XmlId, bookType);
if (categoryData.SubCategories != null)
{
FillCategories(xmlIdToBookType, categoryData.SubCategories);
}
}
}
public RuleResult IsValid(BookTypeEnum book, PropertyTypeEnum propType, DateTime pisDate, DeprMethodTypeEnum deprMethod, int percentage)
{
ErrorCode errorCode;
bool isShortYr = false;
IbpRuleBase rb = new bpRuleBase();
switch (deprMethod)
{
case DeprMethodTypeEnum.MacrsFormula:
case DeprMethodTypeEnum.MacrsTable:
case DeprMethodTypeEnum.MACRSIndianReservation:
case DeprMethodTypeEnum.DeclBal:
case DeprMethodTypeEnum.DeclBalHalfYear:
case DeprMethodTypeEnum.DeclBalModHalfYear:
case DeprMethodTypeEnum.DeclBalSwitch:
case DeprMethodTypeEnum.DeclBalHalfYearSwitch:
case DeprMethodTypeEnum.DeclBalModHalfYearSwitch:
case DeprMethodTypeEnum.MacrsFormula30:
case DeprMethodTypeEnum.MACRSIndianReservation30:
// Build list of percentages.
List <DeprPct> aList = BuildValidList(propType, pisDate, deprMethod);
if (aList != null)
{
// iterate across all percentages, looking for the one
// that matches the one we have. If found, then valid.
// if no matches, then invalid.
foreach (DeprPct item in aList)
{
if (item.Percentage == percentage)
{
return(RuleResult.Valid);
}
}
}
break;
// Canadian BEGIN !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
// The percentage must be in the range [1, 100].
case DeprMethodTypeEnum.CdnDeclBal:
case DeprMethodTypeEnum.CdnDeclBalHalfYear:
case DeprMethodTypeEnum.CdnDeclBalFullMonth:
if ((1 <= percentage) && (percentage <= 100))
{
return(RuleResult.Valid);
}
break;
// Canadian END ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
}
return(RuleResult.Invalid);
}
public virtual IList <long> GetAllBookIdsByBookType(BookTypeEnum currentBookType)
{
using (var session = GetSession())
{
Category catAlias = null;
BookVersion bookVersionAlias = null;
Book bookAlias = null;
return(session.QueryOver <Category>(() => catAlias)
.JoinQueryOver(c => c.BookType).Where(bt => bt.Type == currentBookType)
.JoinQueryOver(() => catAlias.BookVersions, () => bookVersionAlias)
.JoinQueryOver(() => bookVersionAlias.Book, () => bookAlias)
.Where(() => bookVersionAlias.Id == bookAlias.LastVersion.Id)
.Select(Projections.Property(() => bookAlias.Id)).List <long>());
}
}
private BookType GetOrCreateBookTypeForEnum(BookTypeEnum bookTypeEnum)
{
var dbBookType = m_projectRepository.GetBookTypeByEnum(bookTypeEnum);
if (dbBookType == null)
{
dbBookType = new BookType
{
Type = bookTypeEnum
};
m_projectRepository.Create(dbBookType);
}
return(dbBookType);
}
public virtual IList <FavoriteCategory> GetFavoriteCategoriesWithLabel(BookTypeEnum bookType, int userId)
{
Category categoryAlias = null;
BookType bookTypeAlias = null;
using (var session = GetSession())
{
return(session.QueryOver <FavoriteCategory>()
.JoinAlias(x => x.Category, () => categoryAlias)
.JoinAlias(() => categoryAlias.BookType, () => bookTypeAlias)
.Where(x => x.User.Id == userId && bookTypeAlias.Type == bookType)
.Fetch(x => x.FavoriteLabel).Eager
.OrderBy(x => x.Title).Asc
.List());
}
}
public virtual IList <FavoriteQuery> GetFavoriteQueries(long?labelId, BookTypeEnum bookTypeEnum, QueryTypeEnum queryTypeEnum, string filterByTitle, int start, int count, int userId)
{
FavoriteLabel favoriteLabelAlias = null;
using (var session = GetSession())
{
var query = CreateFavoriteQueriesQuery(session, labelId, bookTypeEnum, queryTypeEnum, filterByTitle, userId);
return(query.JoinAlias(x => x.FavoriteLabel, () => favoriteLabelAlias)
.Fetch(x => x.FavoriteLabel).Eager
.Fetch(x => x.BookType).Eager
.OrderBy(x => x.Title).Asc
.OrderBy(() => favoriteLabelAlias.Name).Asc
.Skip(start)
.Take(count)
.List());
}
}
public static IQueryable <Book> TypeBooks(BookTypeEnum booktype)
{
int?type = BookHelper.BookTypeConvert(booktype);
if (type == null)
{
var bs = from book in JianLiLinq.Default.DB.Books
where book.BookType == null
select book;
return(bs);
}
else
{
var bs = from book in JianLiLinq.Default.DB.Books
where book.BookType == type
select book;
return(bs);
}
}
public virtual IList <string> GetLastAuthorsByBookType(int recordCount, BookTypeEnum bookType)
{
using (var session = GetSession())
{
BookVersion bookVersionAlias = null;
Author authorAlias = null;
Category categoryAlias = null;
BookType bookTypeAlias = null;
return(session.QueryOver <Book>()
.JoinQueryOver(x => x.LastVersion, () => bookVersionAlias)
.JoinQueryOver(x => bookVersionAlias.Authors, () => authorAlias)
.JoinQueryOver(x => bookVersionAlias.Categories, () => categoryAlias)
.JoinQueryOver(x => categoryAlias.BookType, () => bookTypeAlias)
.Select(Projections.Distinct(Projections.Property(() => authorAlias.Name)))
.Where(x => bookTypeAlias.Type == bookType)
.Take(recordCount)
.List <string>());
}
}
public RuleResult IsValid(BookTypeEnum book, PropertyTypeEnum propType, DateTime pisDate, DeprMethodTypeEnum deprMethod, int deprPct, YrsMosDate estLife)
{
ErrorCode errorCode;
IbpRuleBase rb = new bpRuleBase();
rb.ValidateEstimatedLife((short)(propType), pisDate, (short)(deprMethod), (int)deprPct, (short)(estLife.Years * 100 + estLife.Months), out errorCode);
switch ((RuleBase_ErrorCodeEnum)errorCode)
{
case RuleBase_ErrorCodeEnum.rulebase_Valid:
return(RuleResult.Valid);
case RuleBase_ErrorCodeEnum.rulebase_Invalid:
return(RuleResult.Invalid);
case RuleBase_ErrorCodeEnum.rulebase_WarnNotUsualRecoveryPd:
return(RuleResult.WarnNotUsualRecoveryPd);
case RuleBase_ErrorCodeEnum.rulebase_WarnNotUsualRecoveryPeriod:
return(RuleResult.WarnNotUsualRecoveryPeriod);
case RuleBase_ErrorCodeEnum.rulebase_WarnNotUsualUnlTransProp:
return(RuleResult.WarnNotUsualUnlTransProp);
case RuleBase_ErrorCodeEnum.rulebase_WarnNotOver20Years:
return(RuleResult.WarnNotOver20Years);
case RuleBase_ErrorCodeEnum.rulebase_WarnAANotOver20Years:
return(RuleResult.WarnAANotOver20Years);
case RuleBase_ErrorCodeEnum.rulebase_WarnOnlyNYLZAllowForRMF100EST0500:
return(RuleResult.WarnOnlyNYLZAllowForRMF100EST0500);
case RuleBase_ErrorCodeEnum.rulebase_RuleBaseFailure:
return(RuleResult.RuleBaseFailure);
}
// section 179 does not apply.
return(RuleResult.Invalid);
}
public virtual IList <BookVersion> SearchByTitleAndBookType(string text, BookTypeEnum bookType)
{
Book bookAlias = null;
BookVersion bookVersionAlias = null;
BookType bookTypeAlias = null;
Category categoryAlias = null;
using (var session = GetSession())
{
var bookVersions =
session.QueryOver(() => bookVersionAlias)
.JoinAlias(() => bookVersionAlias.Categories, () => categoryAlias, JoinType.InnerJoin)
.JoinAlias(() => categoryAlias.BookType, () => bookTypeAlias, JoinType.InnerJoin)
.JoinAlias(() => bookVersionAlias.Book, () => bookAlias, JoinType.InnerJoin)
.Where(() => bookTypeAlias.Type == bookType && bookVersionAlias.Id == bookAlias.LastVersion.Id)
.AndRestrictionOn(() => bookVersionAlias.Title).IsLike(text, MatchMode.Anywhere)
.Fetch(x => x.Authors).Eager
.TransformUsing(Transformers.DistinctRootEntity)
.List <BookVersion>();
return(bookVersions);
}
}
public virtual IList <FavoriteProject> GetFavoriteBooksWithLabel(BookTypeEnum bookType, ProjectTypeEnum?projectType, int userId)
{
FavoriteLabel favoriteLabelAlias = null;
Project projectAlias = null;
Snapshot latestSnapshotAlias = null;
BookType bookTypeAlias = null;
var query = GetSession().QueryOver <FavoriteProject>()
.JoinAlias(x => x.FavoriteLabel, () => favoriteLabelAlias)
.JoinAlias(x => x.Project, () => projectAlias)
.JoinAlias(() => projectAlias.LatestPublishedSnapshot, () => latestSnapshotAlias)
.JoinAlias(() => latestSnapshotAlias.BookTypes, () => bookTypeAlias)
.Where(() => favoriteLabelAlias.User.Id == userId && bookTypeAlias.Type == bookType && projectAlias.IsRemoved == false);
if (projectType != null)
{
query.And(() => projectAlias.ProjectType == projectType.Value);
}
return(query.Fetch(SelectMode.Fetch, x => x.FavoriteLabel)
.OrderBy(x => x.Title).Asc
.List());
}
public virtual IList <MetadataResource> GetMetadataByBookTypeWithCategories(BookTypeEnum bookTypeEnum, int userId, ProjectTypeEnum projectType,
int start, int count)
{
Resource resourceAlias = null;
Snapshot snapshotAlias = null;
BookType bookTypeAlias = null;
Permission permissionAlias = null;
UserGroup userGroupAlias = null;
User userAlias = null;
var resultList = GetSession().QueryOver <MetadataResource>()
.JoinAlias(x => x.Resource, () => resourceAlias)
.Where(x => x.Id == resourceAlias.LatestVersion.Id && !resourceAlias.IsRemoved)
.WithSubquery.WhereProperty(() => resourceAlias.Project.Id).In(QueryOver.Of <Project>()
.Where(x => x.ProjectType == projectType && x.IsRemoved == false)
.JoinAlias(x => x.LatestPublishedSnapshot, () => snapshotAlias)
.JoinAlias(() => snapshotAlias.BookTypes, () => bookTypeAlias)
.Where(() => bookTypeAlias.Type == bookTypeEnum)
.JoinAlias(x => x.Permissions, () => permissionAlias)
.JoinAlias(() => permissionAlias.UserGroup, () => userGroupAlias)
.JoinAlias(() => userGroupAlias.Users, () => userAlias)
.Where(() => userAlias.Id == userId)
.And(BitwiseExpression.On(() => permissionAlias.Flags).HasBit(PermissionFlag.ShowPublished))
.Select(x => x.Id))
.OrderBy(x => x.Title).Asc
.Skip(start)
.Take(count)
.List();
GetSession().QueryOver <Project>()
.WhereRestrictionOn(x => x.Id).IsInG(resultList.Select(x => x.Resource.Project.Id))
.Fetch(SelectMode.Fetch, x => x.Categories)
.List();
return(resultList);
}
public virtual IList <Category> FindCategoriesByBookType(BookTypeEnum type)
{
using (var session = GetSession())
{
Category categoryAlias = null;
BookType bookTypeAlias = null;
var rootCategory = session.QueryOver(() => categoryAlias)
.JoinAlias(x => x.BookType, () => bookTypeAlias)
.Where(() => bookTypeAlias.Type == type && categoryAlias.ParentCategory == null)
.SingleOrDefault <Category>();
if (rootCategory == null)
{
return(new List <Category>());
}
return(session.QueryOver <Category>()
.WhereRestrictionOn(x => x.Path)
.IsLike(rootCategory.Path, MatchMode.Start)
.OrderBy(x => x.Description).Asc
.List <Category>());
}
}
public virtual IList <Category> FindCategoriesByBookTypeii(BookTypeEnum type)
{
using (var session = GetSession())
{
Category categoryAlias = null;
BookType bookTypeAlias = null;
var rootCategory = session.QueryOver(() => categoryAlias)
.JoinAlias(x => x.BookType, () => bookTypeAlias)
.Where(() => bookTypeAlias.Type == type && categoryAlias.ParentCategory == null)
.SingleOrDefault <Category>();
if (rootCategory == null)
{
return(new List <Category>());
}
var resultCategories = new List <Category>();
IList <Category> childCategories = new List <Category> {
rootCategory
};
while (childCategories != null && childCategories.Count() != 0)
{
resultCategories.AddRange(childCategories);
IList <int> parentCategoriesIds = childCategories.Select(childCategory => childCategory.Id).ToList();
var ids = parentCategoriesIds;
childCategories = session.QueryOver(() => categoryAlias)
.Where(() => categoryAlias.ParentCategory.Id.IsIn(ids.ToArray()))
.List <Category>();
}
return(resultCategories);
}
}
public virtual BookType GetBookTypeByEnum(BookTypeEnum bookTypeEnum)
{
return(GetSession().QueryOver <BookType>()
.Where(x => x.Type == bookTypeEnum)
.SingleOrDefault());
}
public virtual ListWithTotalCountResult <FavoriteQuery> GetFavoriteQueries(long?labelId, BookTypeEnum bookTypeEnum, QueryTypeEnum queryTypeEnum, string filterByTitle, int start, int count, int userId)
{
FavoriteQuery favoriteQueryAlias = null;
FavoriteLabel favoriteLabelAlias = null;
BookType bookTypeAlias = null;
var query = GetSession().QueryOver(() => favoriteQueryAlias)
.JoinAlias(() => favoriteQueryAlias.FavoriteLabel, () => favoriteLabelAlias)
.JoinAlias(() => favoriteQueryAlias.BookType, () => bookTypeAlias)
.Where(() => bookTypeAlias.Type == bookTypeEnum && favoriteQueryAlias.QueryType == queryTypeEnum && favoriteLabelAlias.User.Id == userId)
.Fetch(SelectMode.Fetch, x => x.FavoriteLabel)
.Fetch(SelectMode.Fetch, x => x.BookType)
.OrderBy(x => x.Title).Asc
.OrderBy(() => favoriteLabelAlias.Name).Asc;
if (labelId != null)
{
query.And(() => favoriteQueryAlias.FavoriteLabel.Id == labelId.Value);
}
if (!string.IsNullOrEmpty(filterByTitle))
{
filterByTitle = EscapeQuery(filterByTitle);
query.AndRestrictionOn(() => favoriteQueryAlias.Title).IsLike(filterByTitle, MatchMode.Anywhere);
}
var list = query.Skip(start)
.Take(count)
.Future();
var totalCount = query.ToRowCountQuery()
.FutureValue <int>();
return(new ListWithTotalCountResult <FavoriteQuery>
{
List = list.ToList(),
Count = totalCount.Value,
});
}
//Add Book
private void btnAddBook_Click(object sender, EventArgs e)
{
string bookType = cmbBookType.Text;
string title = txtTitle.Text;
double price = double.Parse(txtPrice.Text);
string publisher = txtPublisher.Text;
int yearPublished = int.Parse(txtYearPublished.Text);
int isbn = int.Parse(txtISBN.Text);
int numberOfPages = int.Parse(txtNumberOfPages.Text);
if (bookType == "E-Book")
{
int fileSize = int.Parse(txtFileSize.Text);
EBook newEbook = new EBook(title, price, publisher, yearPublished, isbn, numberOfPages, fileSize);
if (AddNewBook(newEbook))
{
MessageBox.Show("Successful Insertion");
}
else
{
MessageBox.Show("Fail Insertion");
}
}
else if (bookType == "Textbook")
{
BookTypeEnum textBookType = (BookTypeEnum)cmbTextbookType.SelectedItem;
Textbook newTextbook = new Textbook(title, price, publisher, yearPublished, isbn, numberOfPages, textBookType);
if (AddNewBook(newTextbook))
{
MessageBox.Show("Successful Insertion");
}
else
{
MessageBox.Show("Fail Insertion");
}
}
txtTitle.Clear();
txtPrice.Clear();
txtPublisher.Clear();
txtYearPublished.Clear();
txtISBN.Clear();
txtNumberOfPages.Clear();
txtFileSize.Clear();
#region Manual Data Input Test
//Test - input sample date manually first
//EBook eb = new EBook(title, price, publisher, yearPublished, isbn, numberOfPages, fileSize);
//eb.Title = "Book1";
//eb.Price = 6.50;
//eb.Publisher = "Thien";
//eb.YearPublished = 1999;
//eb.ISBN = 1234;
//eb.NumberOfPages = 50;
//eb.FileSize = 1000;
//MessageBox.Show(eb.ToString());
#endregion
}
