public async Task <Response <string> > InsertImageFileName(string userName, string image)
{
try
{
var database = LibManagementConnection.GetConnection();
var userCollection = database.GetCollection <UserDetails>(CollectionConstant.User_Collection);
var builders = Builders <UserDetails> .Filter.And(Builders <UserDetails> .Filter.Where(x => x.UserName == userName));
var update = Builders <UserDetails> .Update.Set("image", image);
var result = await userCollection.FindOneAndUpdateAsync(builders, update);
if (result != null)
{
return(new Response <string>()
{
StatusCode = HttpStatusCode.OK
});
}
else
{
return(new Response <string>()
{
StatusCode = HttpStatusCode.BadRequest
});
}
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <bool> UnBlockBooks(BlockBooks blockedbookdetails)
{
try
{
var database = LibManagementConnection.GetConnection();
var userCollection = database.GetCollection <UserDetails>(CollectionConstant.User_Collection);
ObjectId objectId = ObjectId.Parse(blockedbookdetails.BookID);
var builders = Builders <UserDetails> .Filter.And(Builders <UserDetails> .Filter.Eq(x => x.Id, objectId));
var update = Builders <UserDetails> .Update.PullFilter("blockedBooks", Builders <BsonDocument> .Filter.Eq("isbnNumber", blockedbookdetails.ISBNNumber));
var result = await userCollection.FindOneAndUpdateAsync(builders, update);
if (result != null)
{
return(true);
}
else
{
return(false);
}
}
catch (Exception e)
{
throw e;
}
}
public async Task <bool> DeleteUser(string userName)
{
bool deleteResult = false;
//IClientSessionHandle session = null;
try
{
var database = LibManagementConnection.GetConnection();
// session = database.Client.StartSession();
//session.StartTransaction();
var todoTaskCollection = database.GetCollection <UserDetails>(CollectionConstant.User_Collection);
var result = await todoTaskCollection.FindOneAndDeleteAsync(Builders <UserDetails> .Filter.Eq("username", userName));
if (result != null)
{
var loginCollection = database.GetCollection <LoginDetails>(CollectionConstant.Login_Collection);
var deleteRes = await loginCollection.FindOneAndDeleteAsync(Builders <LoginDetails> .Filter.Eq("username", userName));
if (deleteRes != null)
{
deleteResult = true;
}
}
//session.CommitTransaction();
return(deleteResult);
}
catch (Exception ex)
{
//session?.AbortTransaction();
throw ex;
}
}
public async Task <bool> DeleteBookDetails(ISBNNumber isbnDetails)
{
//IClientSessionHandle session = null;
try
{
var database = LibManagementConnection.GetConnection();
// session = database.Client.StartSession();
//session.StartTransaction();
var todoTaskCollection = database.GetCollection <BookDetails>(CollectionConstant.Book_Collection);
ObjectId objectId = ObjectId.Parse(isbnDetails.BookID);
var builders = Builders <BookDetails> .Filter.And(Builders <BookDetails> .Filter.Eq(x => x.Id, objectId));
var update = Builders <BookDetails> .Update.PullFilter("isbnNumber", Builders <BsonDocument> .Filter.Eq("trackNo", isbnDetails.TrackNo)).Inc("numberOfCopies", -1);
var result = await todoTaskCollection.FindOneAndUpdateAsync(builders, update);
//session.CommitTransaction();
return(true);
}
catch (Exception ex)
{
//session?.AbortTransaction();
throw ex;
}
}
public bool ReturnBooks(IssueBooks issueBooks)
{
try
{
var database = LibManagementConnection.GetConnection();
var booksDetailsCollection = database.GetCollection <BookDetails>(CollectionConstant.Book_Collection);
ObjectId objectId = ObjectId.Parse(issueBooks.BookID);
var data = booksDetailsCollection.Find(x => x.Id == objectId).First();
data.AvailableCopies = data.AvailableCopies + 1;
var details = data.ISBNNumber.First(i => i.TrackNo == issueBooks.ISBNNumber);
details.Occupied = false;
var result = booksDetailsCollection.ReplaceOne(c => c.Id == data.Id, data);
if (result.IsModifiedCountAvailable)
{
return(true);
}
else
{
return(false);
}
}
catch (Exception e)
{
throw e;
}
}
////public async Task<bool> UpdateISBNDetails(ISBNNumber isbnDetails)
////{
//// try
//// {
//// var database = LibManagementConnection.GetConnection();
//// var todoTaskCollection = database.GetCollection<BookDetails>(CollectionConstant.Book_Collection);
//// ObjectId objectId = ObjectId.Parse(isbnDetails.id);
//// var builders = Builders<BookDetails>.Filter.And(Builders<BookDetails>.Filter.Where(x => x.Id == objectId));
//// var update = Builders<BookDetails>.Update.Set("name", bookDetails?.Name).Set("author", bookDetails?.Author).Set("publishingYear", bookDetails?.PublishingYear).Set("image", bookDetails?.Image).Set("lastUpdated", System.DateTime.UtcNow);
//// var result = await todoTaskCollection.FindOneAndUpdateAsync(builders, update);
//// if (result != null)
//// {
//// return true;
//// }
//// else
//// {
//// return false;
//// }
//// }
//// catch (Exception ex)
//// {
//// throw ex;
//// }
////}
public async Task <BookDetails> AddNewBook(BookDetails bookDetails, string image)
{
//IClientSessionHandle session = null;
try
{
var database = LibManagementConnection.GetConnection();
//session = database.Client.StartSession();
//session.StartTransaction();
var todoTaskCollection = database.GetCollection <BookDetails>(CollectionConstant.Book_Collection);
bookDetails.Created = System.DateTime.Now;
if (bookDetails.ISBNNumber.Any())
{
bookDetails.ISBNNumber.FirstOrDefault().Created = System.DateTime.Now;
}
bookDetails.LastUpdated = System.DateTime.Now;
bookDetails.NumberOfCopies = bookDetails.NumberOfCopies + 1;
bookDetails.AvailableCopies = bookDetails.AvailableCopies + 1;
bookDetails.Image = image;
await todoTaskCollection.InsertOneAsync(bookDetails);
//session.CommitTransaction();
return(bookDetails);
}
catch (Exception ex)
{
//session.AbortTransaction();
throw ex;
}
}
public async Task <bool> EditIsbnDetails(ISBNNumber iSBNNumber)
{
try
{
var database = LibManagementConnection.GetConnection();
var booksDetailsCollection = database.GetCollection <BookDetails>(CollectionConstant.Book_Collection);
ObjectId objectId = ObjectId.Parse(iSBNNumber.BookID);
var data = await booksDetailsCollection.FindAsync(x => x.Id == objectId);
var matchedDetails = await data.ToListAsync();
var item = matchedDetails.FirstOrDefault(x => x.Id == objectId);
var details = item.ISBNNumber.First(i => i.TrackNo == iSBNNumber.TrackNo);
details.Author = iSBNNumber.Author;
details.Description = iSBNNumber.Description;
details.Edition = iSBNNumber.Edition;
details.PublishingYear = iSBNNumber.PublishingYear;
var result = booksDetailsCollection.ReplaceOne(c => c.Id == item.Id, item);
if (result.IsModifiedCountAvailable)
{
return(true);
}
else
{
return(false);
}
}
catch (Exception e)
{
throw e;
}
}
public async Task <Response <string> > AddSubCategoryToExistingBook(ISBNNumber isbnDetails)
{
//IClientSessionHandle session = null;
try
{
var database = LibManagementConnection.GetConnection();
//session = database.Client.StartSession();
//session.StartTransaction();
var todoTaskCollection = database.GetCollection <BookDetails>(CollectionConstant.Book_Collection);
ObjectId objectId = ObjectId.Parse(isbnDetails.BookID);
var builders = Builders <BookDetails> .Filter.And(Builders <BookDetails> .Filter.Where(x => x.Id == objectId));
var bookDetails = await todoTaskCollection.Find(builders).ToListAsync();
var IsISBNExists = bookDetails.All(x => x.ISBNNumber.All(y => y.TrackNo == isbnDetails.TrackNo));
if (!IsISBNExists && isbnDetails.BookID != null)
{
isbnDetails.Created = System.DateTime.Now;
var update = Builders <BookDetails> .Update.Push("isbnNumber", isbnDetails).Inc("numberOfCopies", 1).Inc("availableCopies", 1);
var result = await todoTaskCollection.FindOneAndUpdateAsync(builders, update);
//session.CommitTransaction();
if (result != null)
{
return(new Response <string>()
{
StatusCode = System.Net.HttpStatusCode.OK
});
}
else
{
return(new Response <string>()
{
StatusCode = System.Net.HttpStatusCode.NotFound
});
}
}
else
{
return(new Response <string>()
{
StatusCode = System.Net.HttpStatusCode.BadRequest, Message = "ISBN Number Already Exists"
});
}
}
catch (Exception ex)
{
//session?.AbortTransaction();
throw ex;
}
}
public List <IssueBooks> GetAllIssuedbooksToUser(string userId)
{
try
{
var database = LibManagementConnection.GetConnection();
var userCollection = database.GetCollection <UserDetails>(CollectionConstant.User_Collection);
var user = userCollection.Find(x => x.UserName == userId).First();
var issuedbooks = user.IssuedBooks.OrderBy(x => x.ReturnDate).ToList();
return(issuedbooks);
}
catch (Exception e)
{
throw e;
}
}
public UserDetails GetLoggedInUserDetails(string username)
{
try
{
List <UserDetails> userDetails = new List <UserDetails>();
var database = LibManagementConnection.GetConnection();
var todoTaskCollection = database.GetCollection <UserDetails>(CollectionConstant.User_Collection);
var user = todoTaskCollection.Find(x => x.UserName == username).FirstOrDefault();
return(user);
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <ConfigDetails> GetConfigDetails()
{
try
{
ConfigDetails bookList = new ConfigDetails();
var database = LibManagementConnection.GetConnection();
var todoTaskCollection = database.GetCollection <ConfigDetails>(CollectionConstant.Config_Collection);
var docs = await todoTaskCollection.Find(FilterDefinition <ConfigDetails> .Empty).SingleAsync();
return(docs ?? bookList);
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <bool> UpdatePassword(LoginDetails userLoginDetails)
{
//IClientSessionHandle clientSession = null;
try
{
var oldPassword = await passwordRepository.GetEncryptedPassword(userLoginDetails.OldPassword);
var newPassword = await passwordRepository.GetEncryptedPassword(userLoginDetails.Password);
var database = LibManagementConnection.GetConnection();
//clientSession = await database.Client.StartSessionAsync();
var loginCollection = database.GetCollection <LoginDetails>(CollectionConstant.Login_Collection);
var logins = await loginCollection.FindAsync(x => x.UserName == userLoginDetails.UserName && x.Password == oldPassword);
var loginList = await logins.ToListAsync();
if (loginList?.Count > 0)
{
//clientSession.StartTransaction();
userLoginDetails.Password = newPassword;
var builders = Builders <LoginDetails> .Filter.And(Builders <LoginDetails> .Filter.Where(x => x.UserName == userLoginDetails.UserName && x.Password == oldPassword));
var update = Builders <LoginDetails> .Update.Set("password", userLoginDetails.Password);
var result = await loginCollection.FindOneAndUpdateAsync(builders, update);
//await clientSession.CommitTransactionAsync();
if (result != null)
{
return(true);
}
else
{
return(false);
}
}
else
{
return(false);
}
}
catch (Exception e)
{
//await clientSession.AbortTransactionAsync();
throw e;
}
}
public async Task <List <BookDetails> > GetAllAvailableBooks()
{
try
{
var database = LibManagementConnection.GetConnection();
var todoTaskCollection = database.GetCollection <BookDetails>(CollectionConstant.Book_Collection);
var docs = await todoTaskCollection.FindAsync(x => x.NumberOfCopies > 0);
var bookList = await docs.ToListAsync();
return(bookList);
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <List <UserDetails> > GetAllUsers()
{
try
{
List <UserDetails> userDetails = new List <UserDetails>();
var database = LibManagementConnection.GetConnection();
var todoTaskCollection = database.GetCollection <UserDetails>(CollectionConstant.User_Collection);
var docs = await todoTaskCollection.FindAsync(new BsonDocument());
await docs.ForEachAsync(doc => userDetails.Add(doc));
return(userDetails);
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <Response <string> > RegisterUser(LoginDetails userLoginDetails, UserDetails userdetails)
{
//IClientSessionHandle session = null;
try
{
var database = LibManagementConnection.GetConnection();
var userCollection = database.GetCollection <UserDetails>(CollectionConstant.User_Collection);
var loginCollection = database.GetCollection <LoginDetails>(CollectionConstant.Login_Collection);
var logins = await loginCollection.FindAsync(x => x.UserName.ToLower() == userdetails.UserName.ToLower());
var loginsList = await logins.ToListAsync();
string encryptedPassword = await passwordRepository.GetEncryptedPassword(userLoginDetails.Password);
userLoginDetails.Password = encryptedPassword;
if (loginsList?.Count == 0)
{
//session = await database.Client.StartSessionAsync();
//session.StartTransaction();
await loginCollection.InsertOneAsync(userLoginDetails);
await userCollection.InsertOneAsync(userdetails);
//await session.CommitTransactionAsync();
return(new Response <string>()
{
StatusCode = System.Net.HttpStatusCode.OK
});
}
else
{
return(new Response <string>()
{
StatusCode = System.Net.HttpStatusCode.BadRequest, Message = "User Already Exists"
});
}
}
catch (Exception ex)
{
//await session.AbortTransactionAsync();
throw ex;
}
}
public async Task <bool> UpdateBookDetails(BookDetails bookDetails)
{
//IClientSessionHandle session = null;
try
{
if (bookDetails.BookID != null)
{
var database = LibManagementConnection.GetConnection();
//session = database.Client.StartSession();
//session.StartTransaction();
var todoTaskCollection = database.GetCollection <BookDetails>(CollectionConstant.Book_Collection);
ObjectId objectId = ObjectId.Parse(bookDetails.BookID);
var builders = Builders <BookDetails> .Filter.And(Builders <BookDetails> .Filter.Where(x => x.Id == objectId));
var update = Builders <BookDetails> .Update.Set("name", bookDetails?.Name).Set("image", bookDetails?.Image).Set("lastUpdated", System.DateTime.UtcNow);
//.Set("publishingYear", bookDetails?.PublishingYear)
//.Set("author", bookDetails?.Author)
var result = await todoTaskCollection.FindOneAndUpdateAsync(builders, update);
//session.CommitTransaction();
if (result != null)
{
return(true);
}
else
{
return(false);
}
}
else
{
return(false);
}
}
catch (Exception ex)
{
//session?.AbortTransaction();
throw ex;
}
}
public async Task <List <BookDetails> > GetAllBooks()
{
try
{
List <BookDetails> bookList = new List <BookDetails>();
var database = LibManagementConnection.GetConnection();
var todoTaskCollection = database.GetCollection <BookDetails>(CollectionConstant.Book_Collection);
var docs = await todoTaskCollection.FindAsync(new BsonDocument());
await docs.ForEachAsync(doc => bookList.Add(doc));
return(bookList);
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <bool> BlockBooks(BlockBooks blockedbookdetails)
{
try
{
var database = LibManagementConnection.GetConnection();
var bookDetailsCollection = database.GetCollection <BookDetails>(CollectionConstant.Book_Collection);
ObjectId objectId = ObjectId.Parse(blockedbookdetails.BookID);
var builders = Builders <BookDetails> .Filter.And(Builders <BookDetails> .Filter.Eq(x => x.Id, objectId), Builders <BookDetails> .Filter.ElemMatch(x => x.ISBNNumber, c => c.TrackNo == blockedbookdetails.ISBNNumber));
var bookDetails = await bookDetailsCollection.Find(builders).ToListAsync();
var configDetails = await configRepository.GetConfigDetails();
var data = bookDetailsCollection.Find(x => x.Id == objectId).First();
int blockedBooksCount = data.BlockBooks?.Count() ?? 0;
if (blockedBooksCount <= configDetails.BookBlockLimit)
{
var IsISBNExists = bookDetails?.All(x => x.BlockBooks?.Any(y => y.ISBNNumber == blockedbookdetails.ISBNNumber) ?? false);
if (!IsISBNExists ?? false && blockedbookdetails.BookID != null)
{
blockedbookdetails.Created = DateTime.Now;
var update = Builders <BookDetails> .Update.Push("blockedBooks", blockedbookdetails).Inc("availableCopies", -1).Inc("blockedCopies", 1).Set("isbnNumber.$.occupied", true);
var result = await bookDetailsCollection.FindOneAndUpdateAsync(builders, update);
return(true);
}
else
{
return(false);
}
}
else
{
return(false);
}
}
catch (Exception e)
{
throw e;
}
}
public async Task <bool> UpdateUserDetails(UserDetails userDetails)
{
try
{
if (userDetails != null)
{
var database = LibManagementConnection.GetConnection();
//session = database.Client.StartSession();
//session.StartTransaction();
var todoTaskCollection = database.GetCollection <UserDetails>(CollectionConstant.User_Collection);
var builders = Builders <UserDetails> .Filter.And(Builders <UserDetails> .Filter.Where(x => x.UserName.ToLower() == userDetails.UserName.ToLower()));
var update = Builders <UserDetails> .Update.Set("firstName", userDetails.FirstName).Set("middleName", userDetails.MiddleName)
.Set("lastName", userDetails.LastName).Set("image", userDetails.Image).Set("lastUpdated", System.DateTime.UtcNow)
.Set("dob", userDetails.DateofBirth).Set("phoneNumber", userDetails.PhoneNumber);
var result = await todoTaskCollection.FindOneAndUpdateAsync(builders, update);
//session.CommitTransaction();
if (result != null)
{
return(true);
}
else
{
return(false);
}
}
else
{
return(false);
}
}
catch (Exception ex)
{
//session?.AbortTransaction();
throw ex;
}
}
public async Task <bool> IssueBooks(IssueBooks issueBooks)
{
try
{
var database = LibManagementConnection.GetConnection();
var bookDetailsCollection = database.GetCollection <BookDetails>(CollectionConstant.Book_Collection);
ObjectId objectId = ObjectId.Parse(issueBooks.BookID);
var data = await bookDetailsCollection.FindAsync(x => x.Id == objectId);
var bookdata = await data.ToListAsync();
var bookDetails = bookdata.FirstOrDefault();
var blockedbookDetails = bookDetails.BlockBooks.Where(x => x.ISBNNumber == issueBooks.ISBNNumber).ToList();
if (blockedbookDetails.Count > 0)
{
bookDetails.BlockedCopies = bookDetails.BlockedCopies - 1;
bookDetails.ISBNNumber.First(i => i.TrackNo == issueBooks.ISBNNumber).Occupied = true;
bookDetails.BlockBooks = new List <BlockBooks>();
var result = bookDetailsCollection.ReplaceOne(c => c.Id == bookDetails.Id, bookDetails);
//var builders = Builders<BookDetails>.Filter.And(Builders<BookDetails>.Filter.Eq(x => x.Id, objectId));
//var update = Builders<BookDetails>.Update.PullFilter("blockedBooks", Builders<BsonDocument>.Filter.Eq("isbnNumber", issueBooks.ISBNNumber)).Inc("blockedCopies", -1).;
//var response = await bookDetailsCollection.FindOneAndUpdateAsync(builders, update);
return(true);
}
else
{
var details = bookDetails.ISBNNumber.First(i => i.TrackNo == issueBooks.ISBNNumber);
bookDetails.AvailableCopies = bookDetails.AvailableCopies - 1;
details.Occupied = true;
var result = bookDetailsCollection.ReplaceOne(c => c.Id == bookDetails.Id, bookDetails);
return(true);
}
}
catch (Exception e)
{
throw e;
}
}
public async Task <bool> IssueBooksToUser(IssueBooks isbnDetails)
{
try
{
var database = LibManagementConnection.GetConnection();
var userCollection = database.GetCollection <UserDetails>(CollectionConstant.User_Collection);
ObjectId objectId = ObjectId.Parse(isbnDetails.BookID);
var builders = Builders <UserDetails> .Filter.And(Builders <UserDetails> .Filter.Eq(x => x.Id, objectId));
var bookDetails = await userCollection.Find(builders).ToListAsync();
var configDetails = await configRepository.GetConfigDetails();
var data = userCollection.Find(x => x.Id == objectId).First();
int issuedBooksCount = data.IssuedBooks.Count();
if (issuedBooksCount <= configDetails.BookIssueLimit)
{
var IsISBNExists = bookDetails?.Any(x => x.IssuedBooks?.Any(y => y.ISBNNumber == isbnDetails.ISBNNumber) ?? false);
if (!IsISBNExists ?? false && isbnDetails.BookID != null)
{
isbnDetails.IssuedOn = DateTime.Now;
isbnDetails.ReturnDate = isbnDetails.IssuedOn.AddDays(15);
var update = Builders <UserDetails> .Update.Push("issuedBooks", isbnDetails);
var result = await userCollection.FindOneAndUpdateAsync(builders, update);
}
return(true);
}
else
{
return(false);
}
}
catch (Exception e)
{
throw e;
}
}
public async Task <bool> CheckUserNameAvailability(string userName)
{
try
{
var database = LibManagementConnection.GetConnection();
var userCollection = database.GetCollection <UserDetails>(CollectionConstant.Login_Collection);
var user = await userCollection.FindAsync(x => x.UserName.ToUpper() == userName.ToUpper());
var result = await user.ToListAsync();
if (result?.Count > 0)
{
return(false);
}
else
{
return(true);
}
}
catch (Exception e)
{
throw e;
}
}
public async Task <bool> UpdateConfigDetails(ConfigDetails configDetails)
{
try
{
if (configDetails.Id != null)
{
var database = LibManagementConnection.GetConnection();
var todoTaskCollection = database.GetCollection <ConfigDetails>(CollectionConstant.Config_Collection);
ObjectId objectId = ObjectId.Parse(configDetails.ConfigId);
var builders = Builders <ConfigDetails> .Filter.And(Builders <ConfigDetails> .Filter.Where(x => x.Id == objectId));
var update = Builders <ConfigDetails> .Update.Set("bookIssueLimit", configDetails.BookIssueLimit)
.Set("bookBlockLimit", configDetails.BookBlockLimit)
.Set("returnDays", configDetails.ReturnDays);
var result = await todoTaskCollection.FindOneAndUpdateAsync(builders, update);
if (result != null)
{
return(true);
}
else
{
return(false);
}
}
else
{
return(false);
}
}
catch (Exception ex)
{
throw ex;
}
}
