/// <summary>
/// Get All user from MongoDb collection
/// </summary>
/// <returns></returns>
public async Task <IEnumerable <ApplicationUser> > GetAllUser()
{
try
{
var list = _mongoContext.GetCollection <ApplicationUser>("ApplicationUser")
.Find(Builders <ApplicationUser> .Filter.Empty, null)
.SortByDescending(e => e.FirstName);
return(await list.ToListAsync());
}
catch (Exception ex)
{
throw (ex);
}
}
/// <summary>
/// Get User by Id from ApplicationUser collection
/// </summary>
/// <param name="UserId"></param>
/// <returns></returns>
public async Task <ApplicationUser> GetUserById(string UserId)
{
try
{
var objectId = new ObjectId(UserId);
FilterDefinition <ApplicationUser> filter = Builders <ApplicationUser> .Filter.Eq("UserId", objectId);
_dbCollection = _mongoContext.GetCollection <ApplicationUser>(typeof(ApplicationUser).Name);
return(await _dbCollection.FindAsync(filter).Result.FirstOrDefaultAsync());
}
catch (Exception ex)
{
throw (ex);
}
}
/// <summary>
/// Add new Commnet BlogPosst in MongoDb
/// </summary>
/// <param name="postId"></param>
/// <param name="comments"></param>
/// <returns>Comment object if create Comments is ok(200)</returns>
public async Task <Comment> Comments(string postId, Comment comments)
{
try
{
if (postId == null && comments == null)
{
throw new ArgumentNullException(typeof(Comment).Name + "Object and Id is Null");
}
_dbCommentsCollection = _mongoContext.GetCollection <Comment>(typeof(Comment).Name);
await _dbCommentsCollection.InsertOneAsync(comments);
}
catch (Exception ex)
{
throw (ex);
}
return(comments);
}
/// <summary>
/// Add a new interview into MongoDb Collection
/// </summary>
/// <param name="interview"></param>
/// <returns></returns>
public async Task <Interview> AddInterview(Interview interview)
{
try
{
if (interview == null)
{
throw new ArgumentNullException(typeof(Interview).Name + "Object is Null");
}
_dbCollection = _mongoContext.GetCollection <Interview>(typeof(Interview).Name);
await _dbCollection.InsertOneAsync(interview);
}
catch (Exception ex)
{
throw (ex);
}
return(interview);
}
/// <summary>
/// Add new Book to MongoDb collection
/// </summary>
/// <param name="book"></param>
/// <returns></returns>
public async Task <Book> AddNewBook(Book book)
{
try
{
if (book == null)
{
throw new ArgumentNullException(typeof(Book).Name + "Object is Null");
}
_book = _mongoContext.GetCollection <Book>(typeof(Book).Name);
await _book.InsertOneAsync(book);
}
catch (Exception ex)
{
throw (ex);
}
return(book);
}
////Add new Allot Movie
public async Task <AllotMovie> AddAllot(AllotMovie allotMovie)
{
try
{
if (allotMovie == null)
{
throw new ArgumentNullException(typeof(MultiplexManagement).Name + " object is null");
}
_moviedbCollection = _mongoContext.GetCollection <AllotMovie>(typeof(AllotMovie).Name);
await _moviedbCollection.InsertOneAsync(allotMovie);
return(allotMovie);
}
catch (Exception ex)
{
throw (ex);
}
}
public async Task <ContactUs> ContactUs(ContactUs contact)
{
try
{
if (contact == null)
{
throw new ArgumentNullException(typeof(ContactUs).Name + " object is null");
}
_dbCollection = _mongoContext.GetCollection <ContactUs>(typeof(ContactUs).Name);
await _dbCollection.InsertOneAsync(contact);
return(contact);
}
catch (Exception ex)
{
throw (ex);
}
}
//register new buyer
public async Task <Buyer> RegisterAsync(Buyer buyer)
{
try
{
if (buyer == null)
{
throw new ArgumentNullException(typeof(Buyer).Name + " object is null");
}
_buyerdbCollection = _mongoContext.GetCollection <Buyer>(typeof(Buyer).Name);
await _buyerdbCollection.InsertOneAsync(buyer);
return(buyer);
}
catch (Exception ex)
{
throw (ex);
}
}
////Add new Multiplex
public async Task <MultiplexManagement> AddMultiplex(MultiplexManagement multiplexManagement)
{
try
{
if (multiplexManagement == null)
{
throw new ArgumentNullException(typeof(MultiplexManagement).Name + " object is null");
}
_moviedbCollection = _mongoContext.GetCollection <MultiplexManagement>(typeof(MultiplexManagement).Name);
await _moviedbCollection.InsertOneAsync(multiplexManagement);
return(multiplexManagement);
}
catch (Exception ex)
{
throw (ex);
}
}
public UserRepository(IMongoDBContext context)
{
var camelCaseConvention = new ConventionPack {
new CamelCaseElementNameConvention()
};
ConventionRegistry.Register("CamelCase", camelCaseConvention, type => true);
_ctx = context;
_userCollections = _ctx.GetCollection <User>("Users");
}
public EventsRepository(IMongoDBContext context)
{
var camelCaseConvention = new ConventionPack {
new CamelCaseElementNameConvention()
};
ConventionRegistry.Register("CamelCase", camelCaseConvention, type => true);
_ctx = context;
_eventsCollection = _ctx.GetCollection <Events>("Events");
}
/// <summary>
/// Add New Category in MongoDb Collection
/// </summary>
/// <param name="category"></param>
/// <returns></returns>
public async Task <Category> AddCategory(Category category)
{
try
{
if (category == null)
{
throw new ArgumentNullException(typeof(Category).Name + "Object is Null");
}
_dbcatCollection = _mongoContext.GetCollection <Category>(typeof(Category).Name);
await _dbcatCollection.InsertOneAsync(category);
}
catch (Exception ex)
{
throw(ex);
}
return(category);
}
/// <summary>
/// Get All Notice from Notice Db Collection
/// </summary>
/// <returns></returns>
public async Task <IEnumerable <Notice> > AllNotice()
{
try
{
var list = _mongoContext.GetCollection <Notice>("Notice")
.Find(Builders <Notice> .Filter.Empty, null)
.SortByDescending(e => e.NoticeId);
return(await list.ToListAsync());
}
catch (Exception ex)
{
throw (ex);
}
}
/// <summary>
/// Add Notice in Notice Db Collection
/// </summary>
/// <param name="notice"></param>
/// <returns></returns>
public async Task <Notice> AddNotice(Notice notice)
{
try
{
if (notice == null)
{
throw new ArgumentNullException(typeof(Notice).Name + "Object is Null");
}
_dbNCollection = _mongoContext.GetCollection <Notice>(typeof(Notice).Name);
await _dbNCollection.InsertOneAsync(notice);
}
catch (Exception ex)
{
throw (ex);
}
return(notice);
}
/// <summary>
/// Get All Poduct from Product Collection
/// </summary>
/// <returns></returns>
public async Task <IEnumerable <Product> > GetAllProduct()
{
try
{
var list = _mongoContext.GetCollection <Product>("Product")
.Find(Builders <Product> .Filter.Empty, null)
.SortByDescending(e => e.ProductName);
return(await list.ToListAsync());
}
catch (Exception ex)
{
throw (ex);
}
}
/// <summary>
/// Add new doctor in MongoDb Collection
/// </summary>
/// <param name="doctor"></param>
/// <returns></returns>
public async Task <Doctor> AddnewDoctor(Doctor doctor)
{
try
{
if (doctor == null)
{
throw new ArgumentNullException(typeof(Doctor).Name + "Object is Null");
}
_dbDCollection = _mongoContext.GetCollection <Doctor>(typeof(Doctor).Name);
await _dbDCollection.InsertOneAsync(doctor);
}
catch (Exception ex)
{
throw (ex);
}
return(doctor);
}
/// <summary>
/// Find Forum thread by name as well email
/// </summary>
/// <param name="Name"></param>
/// <returns></returns>
public async Task <IEnumerable <ForumThread> > FindForumThread(string Name)
{
try
{
var filterBuilder = new FilterDefinitionBuilder <ForumThread>();
var findName = filterBuilder.Eq(s => s.ThreadName, Name);
var findEmail = filterBuilder.Eq(s => s.Email, Name.ToString());
_dbFCollection = _mongoContext.GetCollection <ForumThread>(typeof(ForumThread).Name);
var result = await _dbFCollection.FindAsync(findName | findEmail).Result.ToListAsync();
return(result);
}
catch (Exception ex)
{
throw (ex);
}
}
//injecting dbContext and geetting collection
public ViewOrderServices(IMongoDBContext context)
{
_mongoContext = context;
_dbCollection = _mongoContext.GetCollection <GiftOrder>(typeof(GiftOrder).Name);
}
//Injecting mongoContext in constructor
public BlogPostRepository(IMongoDBContext context)
{
_mongoContext = context;
_dbCollection = _mongoContext.GetCollection <BlogPost>(typeof(BlogPost).Name);
_dbCommentsCollection = _mongoContext.GetCollection <Comment>(typeof(Comment).Name);
}
/// <summary>
/// Injecting Referance variable in UserGroceryRepository class Constructor
/// </summary>
public UserGroceryRepository(IMongoDBContext context)
{
_mongoContext = context;
_dbCollection = _mongoContext.GetCollection <ApplicationUser>(typeof(ApplicationUser).Name);
}
public AdminDiscussionForumRepository(IMongoDBContext context)
{
_mongoContext = context;
_dbFCollection = _mongoContext.GetCollection <ForumThread>(typeof(ForumThread).Name);
_dbACollection = _mongoContext.GetCollection <ApplicationUser>(typeof(ApplicationUser).Name);
}
public ColumnGroupRepository(IMongoDBContext context)
{
_context = context;
_collection = _context.GetCollection <ColumnGroup>("ColumnGroups");
}
public WeatherRepository(IMongoDBContext context)
{
_collection = context.GetCollection <CityWeather>("WeatherAPI");
}
public BillRepository(IMongoDBContext context)
{
_mongoContext = context;
_mongoCollection = _mongoContext.GetCollection <BillDetails>(typeof(BillDetails).Name);
}
/// <summary>
/// get list of all categories
/// </summary>
/// <returns></returns>
public IList <Category> CategoryList()
{
try
{
var list = _mongoContext.GetCollection <Category>("Category")
.Find(Builders <Category> .Filter.Empty, null)
.SortByDescending(e => e.Title);
return(list.ToList());
}
catch (Exception ex)
{
throw (ex);
}
}
protected BaseRepository(IMongoDBContext context)
{
_mongoContext = context;
_dbCollection = _mongoContext.GetCollection <TEntity>(typeof(TEntity).Name);
}
/// <summary>
/// Inject mongodbcontext object
/// </summary>
/// <param name="mongoDBContext"></param>
public TaskRepository(IMongoDBContext mongoDBContext)
{
_mongoDBContext = mongoDBContext;
_mongoCollection = _mongoDBContext.GetCollection <TaskItem>(typeof(TaskItem).Name);
_mongoCollectionGroup = _mongoDBContext.GetCollection <TaskGroup>(typeof(TaskGroup).Name);
}
public UserRepository(IMongoDBContext mongoDBContext)
{
_mongoDBContext = mongoDBContext;
_mongoCollection = _mongoDBContext.GetCollection <User>(typeof(User).Name);
}
protected BaseRepository(IMongoDBContext context)
{
_mongoContext = context ?? throw new ArgumentNullException(nameof(context));
_dbCollection = _mongoContext.GetCollection <T>();
}
public BaseRepository(IMongoDBContext dbContext)
{
this._dbContext = dbContext;
Collection = _dbContext.GetCollection <TEntity>();
}
