private static void CreateProject()
{
//AsymmetricEncryption.GenerateRegisterFile("yazhi.pang", "autox");
var fileContent = File.ReadAllText("yazhi.pang.pem");
var forSake = XElement.Parse(fileContent);
var projectName = forSake.GetAttributeValue("ProjectName");
if (MongoDBManager.GetInstance().IsProjectExisted(projectName))
{
Console.WriteLine("Project already existed, continue?(y/n):");
if (!Console.ReadKey().KeyChar.Equals('y'))
{
return;
}
}
MongoDBManager.GetInstance().SetProject(projectName);
var root = forSake.Element("Root");
var publicAndPrivateKey = root.GetAttributeValue("PublicAndPrivateKey");
var secret = root.GetAttributeValue("Secret");
var decrypted = AsymmetricEncryption.DecryptText(secret, 2048, publicAndPrivateKey);
var userName = root.GetAttributeValue("UserName");
foreach (XElement descendant in forSake.Descendants())
{
DBFactory.GetData().Save(descendant);
}
}
static void Main(string[] args)
{
Dictionary <string, OnlineScript> DicOnlineScripts = new Dictionary <string, OnlineScript>();
MongoDBManager Databse = new MongoDBManager();
Databse.Init();
Server OnlineServer = new Server(Databse, DicOnlineScripts);
DicOnlineScripts.Add(AskGameDataScriptServer.ScriptName, new AskGameDataScriptServer());
DicOnlineScripts.Add(AskLoginScriptServer.ScriptName, new AskLoginScriptServer(OnlineServer));
DicOnlineScripts.Add(Core.Online.AskJoinRoomScriptServer.ScriptName, new AskJoinRoomScriptServer(OnlineServer));
DicOnlineScripts.Add(AskRoomListScriptServer.ScriptName, new AskRoomListScriptServer(OnlineServer));
DicOnlineScripts.Add(CreateRoomTripleThunderScriptServer.ScriptName, new CreateRoomTripleThunderScriptServer(OnlineServer, TripleThunderClientGroup.Template));
DicOnlineScripts.Add(SendGameDataScriptServer.ScriptName, new SendGameDataScriptServer(OnlineServer));
DicOnlineScripts.Add(TransferRoomScriptServer.ScriptName, new TransferRoomScriptServer(OnlineServer, TripleThunderClientGroup.Template));
IniFile ConnectionInfo = IniFile.ReadFromFile("ConnectionInfo.ini");
string PublicIP = ConnectionInfo.ReadField("ServerInfo", "PublicIP");
int PublicPort = int.Parse(ConnectionInfo.ReadField("ServerInfo", "PublicPort"));
OnlineServer.StartListening(PublicIP, PublicPort);
Console.ReadKey();
OnlineServer.StopListening();
}
public async Task <ActionResult> ShowMovieInformation(string id)
{
var oid = new ObjectId(id);
MongoDBManager mm = new MongoDBManager();
Movie movie = await mm.GetMovie(oid);
var userRating = mm.GetUserRating(User.Identity.GetUserId(), oid);
ShowMovieInformationViewModel model = new ShowMovieInformationViewModel()
{
ID = oid,
Director = movie.Director,
Actors = movie.Actors,
Genres = movie.Genres,
ImdbRating = movie.ImdbRating,
TmdbRating = movie.TMDbRating,
YouTube = movie.YouTube,
Title = movie.Title,
Runtime = movie.Runtime,
Poster = movie.Poster,
Plot = movie.Plot,
Language = movie.Language,
MetascoreRating = movie.MetascoreRating,
Released = movie.Released.Value,
AvgUserRating = movie.AvgUserRating
};
if (userRating != null)
{
model.Liked = true;
model.UserRating = userRating.UserRating;
}
return(View(model));
}
public async Task <ActionResult> ShowUserMovies(int?page)
{
MongoDBManager mm = new MongoDBManager();
UserInformation user = await mm.GetUserInformation(User.Identity.GetUserId());
List <MovieListModel> movies = new List <MovieListModel>();
if (user.MovieLikes != null)
{
foreach (var userMovie in user.MovieLikes)
{
MovieListModel newMovie = new MovieListModel()
{
AvgUserRating = userMovie.UserRating,
ID = userMovie.Id,
Title = userMovie.Name
};
var movie = await mm.GetMovie(userMovie.Id);
newMovie.Poster = movie.Poster;
movies.Add(newMovie);
}
}
return(View(movies.ToPagedList(page ?? 1, 12)));
}
public ActionResult UpdateTweets()
{
MongoDBManager mm = new MongoDBManager();
mm.InsertNewTweets();
return(View("ShowTweets", mm.GetAllTweets()));
}
public async Task <ActionResult> DislikeMovie(string movieID)
{
ObjectId oid = new ObjectId(movieID);
MongoDBManager mm = new MongoDBManager();
await mm.DislikeMovie(User.Identity.GetUserId(), oid);
return(Json(string.Empty));
}
public async Task <ActionResult> UpdateUserRating(string movieID, int rating)
{
ObjectId oid = new ObjectId(movieID);
MongoDBManager mm = new MongoDBManager();
await mm.UpdateUserRating(User.Identity.GetUserId(), oid, rating);
return(Json(string.Empty));
}
public TransactionManager(IContextProviderFactory contextProvider, UserResolverService userService, MongoDBManager _mongoManager
, AuditLogRepository _auditLogRepository)
{
//Context = context;
Context = contextProvider.dbContext;
auditLogRepository = _auditLogRepository;
mongoManager = _mongoManager;
currentUserId = userService.GetCurrentUser();
}
public async Task <ActionResult> LikeMovie(string movieID)
{
ObjectId oid = new ObjectId(movieID);
System.Diagnostics.Debug.WriteLine(movieID);
MongoDBManager mm = new MongoDBManager();
await mm.LikeMovie(User.Identity.GetUserId(), oid);
return(Json(string.Empty));
}
private MongoCursor <IncomeMDO> GetIncomeMongoCursor(MongoDB.Driver.IMongoQuery incomeMongoQuery, int currentPage)
{
int rowCount = (currentPage * NumberOfRowsPerPage);
int skipPageCount = rowCount != 0 ? (rowCount - NumberOfRowsPerPage) : 0;
MongoCursor <IncomeMDO> incomeMongoCursor = new MongoDBManager().Find <IncomeMDO>("Incomes", incomeMongoQuery);
incomeMongoCursor.Skip = skipPageCount; //------> Setting the skip count
incomeMongoCursor.Limit = NumberOfRowsPerPage; //-----> Setting the take count (Limit)
incomeMongoCursor.SetSortOrder(SortBy.Descending("IncomeDate", "CreatedDate")); //Setting the sort order before executing
return(incomeMongoCursor);
}
public static void TestDbClient(MongoDBManager mdm)
{
Client client = new Client();
client.AvailabilityStart = "0:00";
client.AvailabilityEnd = "0:00";
client.Name = "VDR";
client.Priority = 1;
client.MaximumJobs = 2;
client.Online = false;
mdm.InsertClient(client);
}
public static void TestDbJob(MongoDBManager mdm)
{
List <Client> clients = mdm.GetClients();
Job job = new Job {
Name = "Neva Give üp",
Subtitle = "Der einzig wahre Japaner",
Path = "D:\\Recording\\Neva Give üp - Der einzig wahre Japaner.mkv",
AssignedClient = new MongoDB.Driver.MongoDBRef("clients", clients.First().Id),
};
mdm.InsertJob(job);
}
public async Task <List <Movie> > GetRecommendedMovies(string userID)
{
MongoDBManager mm = new MongoDBManager();
List <Movie> movies = new List <Movie>();
Dictionary <ObjectId, int> similarMovies = new Dictionary <ObjectId, int>();
UserInformation user = await mm.GetUserInformation(userID);
if (user == null)
{
return(movies);
}
foreach (var movieLike in user.MovieLikes)
{
List <UserInformation> users = mm.GetAllUsersWithExceptCurrent(userID, movieLike);
foreach (var userFromDb in users)
{
foreach (var movie in userFromDb.MovieLikes)
{
if (!similarMovies.ContainsKey(movie.Id))
{
similarMovies.Add(movie.Id, 0);
}
similarMovies[movie.Id]++;
}
}
}
var sortedSimilarMovies = from pair in similarMovies
orderby pair.Value descending
select pair;
int counter = 0;
foreach (var sortedSimilarMovie in sortedSimilarMovies)
{
if (user.MovieLikes.Exists(x => x.Id == sortedSimilarMovie.Key))
{
continue;
}
counter++;
movies.Add(await mm.GetMovie(sortedSimilarMovie.Key));
}
return(movies);
}
public async Task <ActionResult> UpdateUserLikes(IndexViewModel model, int?page)
{
if (Session["tokenFB"] != null)
{
MongoDBManager mm = new MongoDBManager();
List <MovieLike> movies = await mm.UpdateUserLikes(User.Identity.GetUserId(), Session["tokenFB"].ToString());
return(View("ShowUserMovies", movies));
}
else
{
return(View("ShowUserMovies", (new List <MovieLike>()).ToPagedList(page ?? 1, 12)));
}
}
//
//show user information
public async Task <ActionResult> ShowUserInformation()
{
MongoDBManager mm = new MongoDBManager();
UserInformation user = await mm.GetUserInformation(User.Identity.GetUserId());
ShowUserInformationViewModel model = new ShowUserInformationViewModel()
{
Birthday = user.Birthday,
FirstName = user.FirstName,
LastName = user.LastName,
Email = user.Email
};
return(View(model));
}
/// <summary>
/// Get all expenses by using MongoQuery
/// </summary>
/// <param name="userId"></param>
/// <param name="currentPage"></param>
/// <param name="expenseDate"></param>
/// <param name="expenseTypes"></param>
/// <returns></returns>
public IList <IExpense> GetAll(int userId, int currentPage, DateTime expenseDate, string expenseMonth, IList <IExpenseType> expenseTypes = null)
{
MongoDB.Driver.IMongoQuery expenseMongoQuery = this.GetExpenseMongoQuery(userId, expenseDate, expenseMonth, expenseTypes);
int totalExpenseCount = new MongoDBManager().GetCountByQuery <ExpenseMDO>(EXPENSES, expenseMongoQuery); //-----> MongoDb call to get the count.
if (totalExpenseCount < ((currentPage - 1) * NumberOfRowsPerPage))
{
currentPage = 1;
}
MongoCursor <ExpenseMDO> expenseMongoCursor = this.GetExpenseMongoCursor(expenseMongoQuery, currentPage);
List <IExpense> expenses = this.MapExpenseMDOCollectionToDomainList(expenseMongoCursor.ToList());//-----> MongoDb Call to get the filtered incomes.
expenses.ForEach(a => a.TotalCount = totalExpenseCount);
return(expenses);
}
/// <summary>
/// Get all incomes by using MongoQuery
/// </summary>
/// <param name="userId"></param>
/// <param name="currentPage"></param>
/// <param name="incomeDate"></param>
/// <param name="incomeTypes"></param>
/// <returns></returns>
public List <IIncome> GetAllByMongoQuery(int userId, int currentPage, DateTime incomeDate, List <IIncomeType> incomeTypes = null)
{
MongoDB.Driver.IMongoQuery incomeMongoQuery = this.GetIncomeMongoQuery(userId, incomeDate, incomeTypes);
int totalIncomeCount = new MongoDBManager().GetCountByQuery <IncomeMDO>("Incomes", incomeMongoQuery); //-----> MongoDb call to get the count.
if (totalIncomeCount < ((currentPage - 1) * NumberOfRowsPerPage))
{
currentPage = 1;
}
MongoCursor <IncomeMDO> incomeMongoCursor = this.GetIncomeMongoCursor(incomeMongoQuery, currentPage);
List <IIncome> incomes = this.MapIncomeMDOCollectionToDomainList(incomeMongoCursor.ToList());//-----> MongoDb Call to get the filtered incomes.
incomes.ForEach(a => a.TotalCount = totalIncomeCount);
return(incomes);
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = model.Email, Email = model.Email
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
// For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=320771
// Send an email with this link
// string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
// var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
// await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>");
// Get the information about the user from the external login provider
UserInformation facebookUser = new UserInformation()
{
Birthday = default(DateTime),
FirstName = "",
LastName = "",
Email = user.Email,
Id = user.Id
};
facebookUser.MovieLikes = new List <MovieLike>();
MongoDBManager mongoManager = new MongoDBManager();
mongoManager.InsertNewUser(facebookUser);
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
return(RedirectToAction("Index", "Home"));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
private IQueryable <ExpenseMDO> GetExpenseQuery(int userId, DateTime expenseDate, IList <IExpenseType> expenseTypes = null)
{
IQueryable <ExpenseMDO> expenseCollection = new MongoDBManager().GetAll <ExpenseMDO>(EXPENSES);
IQueryable <ExpenseMDO> expenseFilteredCollection = (from i in expenseCollection.Where(x => x.UserId == userId) select i);
if (!expenseDate.IsDefault())
{
expenseFilteredCollection = expenseFilteredCollection.Where <ExpenseMDO>(x => x.ExpenseDate == expenseDate);
if ((expenseTypes != null && expenseTypes.Any()))
{
List <int> expenseTypeIds = expenseTypes.Select(t => t.TypeId).ToList <int>();
expenseFilteredCollection = expenseFilteredCollection.Where <ExpenseMDO>(x => x.ExpenseType.TypeId.In(expenseTypeIds));
}
}
else if ((expenseTypes != null && expenseTypes.Any()))
{
List <int> expenseTypeIds = expenseTypes.Select(t => t.TypeId).ToList <int>();
expenseFilteredCollection = expenseFilteredCollection.Where <ExpenseMDO>(x => x.ExpenseType.TypeId.In(expenseTypeIds));
}
return(expenseFilteredCollection.OrderByDescending(x => x.ExpenseDate)); // Order by desc by expense date (not considering Modified Date)
}
public async Task <ActionResult> Index(int?page)
{
MongoDBManager mm = new MongoDBManager();
var movies = await mm.GetMovies();
List <MovieListModel> listMovies = new List <MovieListModel>();
foreach (var m in movies)
{
MovieListModel newMovie = new MovieListModel()
{
AvgUserRating = m.AvgUserRating,
ID = m.ID,
Title = m.Title
};
var movie = await mm.GetMovie(m.ID);
newMovie.Poster = movie.Poster;
listMovies.Add(newMovie);
}
return(View(listMovies.ToPagedList(page ?? 1, 12)));
}
private IQueryable <IncomeMDO> GetIncomeQuery(int userId, DateTime incomeDate, List <IIncomeType> incomeTypes = null)
{
IQueryable <IncomeMDO> incomeCollection = new MongoDBManager().GetAll <IncomeMDO>("Incomes");
IQueryable <IncomeMDO> incomeFilteredCollection = (from i in incomeCollection.Where(x => x.UserId == userId)
//orderby i.RowNumber ascending
select i);
if (!incomeDate.IsDefault())
{
incomeFilteredCollection = incomeFilteredCollection.Where <IncomeMDO>(x => x.IncomeDate == incomeDate);
if ((incomeTypes != null && incomeTypes.Any()))
{
List <int> incomeTypeIds = incomeTypes.Select(t => t.TypeId).ToList <int>();
incomeFilteredCollection = incomeFilteredCollection.Where <IncomeMDO>(x => x.IncomeType.TypeId.In(incomeTypeIds));
}
}
else if ((incomeTypes != null && incomeTypes.Any()))
{
List <int> incomeTypeIds = incomeTypes.Select(t => t.TypeId).ToList <int>();
incomeFilteredCollection = incomeFilteredCollection.Where <IncomeMDO>(x => x.IncomeType.TypeId.In(incomeTypeIds));
}
return(incomeFilteredCollection);
}
/// <summary>
/// Initializes the Infuser with command line parameters and database storage capabilities
/// and retrieves the console application's execution directory.
/// </summary>
/// <param name="args">Command line parameters from Main</param>
/// <param name="lgr">A Logger</param>
/// <param name="mdm">MongoDB Wrapper for data manipulation</param>
public Infuser(string[] args, Log lgr, MongoDBManager mdm) : this(args, lgr)
{
this.mdm = mdm;
}
public async Task <ActionResult> ExternalLoginConfirmation(ExternalLoginConfirmationViewModel model, string returnUrl)
{
if (User.Identity.IsAuthenticated)
{
return(RedirectToAction("Index", "Manage"));
}
if (ModelState.IsValid)
{
// Get the information about the user from the external login provider
var info = await AuthenticationManager.GetExternalLoginInfoAsync();
if (info == null)
{
return(View("ExternalLoginFailure"));
}
var user = new ApplicationUser {
UserName = model.Email, Email = model.Email
};
var result = await UserManager.CreateAsync(user);
if (result.Succeeded)
{
result = await UserManager.AddLoginAsync(user.Id, info.Login);
if (result.Succeeded)
{
var fb = new FacebookClient(Session["tokenFB"].ToString());
dynamic data = new System.Dynamic.ExpandoObject();
data.FirstName = "";
data.LastName = "";
data.Birthday = default(DateTime);
data.movies = null;
//data.Birthday = "";
data = fb.Get("/me?fields=first_name,last_name,email,birthday,movies");
UserInformation facebookUser = new UserInformation()
{
Birthday = DateTime.ParseExact(data.birthday, "MM/dd/yyyy", CultureInfo.InvariantCulture),
//Birthday = data.Birthday,
FirstName = data.first_name,
LastName = data.last_name,
Email = model.Email,
Id = user.Id
};
facebookUser.MovieLikes = new List <MovieLike>();
if (data.movies != null)
{
foreach (dynamic movie in data.movies.data)
{
TMDbManager movieManager = new TMDbManager();
MongoDBManager mm = new MongoDBManager();
var exists = await mm.FindMoviesByName((string)movie.name);
ObjectId?movieId = null;
if (exists.Count >= 1)
{
movieId = exists.First().ID;
}
else
{
movieId = await movieManager.InsertMovieByName(movie.name);
}
if (movieId != null)
{
facebookUser.MovieLikes.Add(new MovieLike()
{
Id = movieId.Value, Name = movie.name
});
}
}
}
MongoDBManager mongoManager = new MongoDBManager();
mongoManager.InsertNewUser(facebookUser);
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
return(RedirectToLocal(returnUrl));
}
}
AddErrors(result);
}
ViewBag.ReturnUrl = returnUrl;
return(View(model));
}
public ActionResult ShowTweets()
{
MongoDBManager mm = new MongoDBManager();
return(View("ShowTweets", mm.GetAllTweets()));
}
public static void GenerateProductReports(string folderName)
{
DirectoryInfo directory = Directory.CreateDirectory(folderName);
List<MongoProductReport> mongoProductsReports = new List<MongoProductReport>();
MongoDBManager<MongoProductReport> mongo = new MongoDBManager<MongoProductReport>();
using (var msSQLServerContext = new SupermarketEntities())
{
var sales =
from product in msSQLServerContext.Products
join vendor in msSQLServerContext.Vendors
on product.VendorId equals vendor.VendorId
join sale in msSQLServerContext.Sales
on product.ProductId equals sale.ProductId
group sale by sale.ProductId into productsById
select new
{
ProductId = productsById.Key,
SalesTotalQuantity = productsById.Sum(s => s.ProductQuantity),
SalesTotalSum = productsById.Sum(s => s.ProductTotalSum)
};
var productReports =
from sale in sales
join product in msSQLServerContext.Products
on sale.ProductId equals product.ProductId
join vendor in msSQLServerContext.Vendors
on product.VendorId equals vendor.VendorId
select new
{
ProductId = sale.ProductId,
ProductName = product.ProductName,
VendorName = vendor.VendorName,
SalesTotalQuantity = sale.SalesTotalQuantity,
SalesTotalSum = sale.SalesTotalSum
};
foreach (var productReport in productReports)
{
JObject jsonObject = new JObject(
new JProperty("product-id", productReport.ProductId),
new JProperty("product-name", productReport.ProductName),
new JProperty("vendor-name", productReport.VendorName),
new JProperty("total-quantity-sold", productReport.SalesTotalQuantity),
new JProperty("total-incomes", productReport.SalesTotalSum));
string filePath = Path.Combine(folderName, string.Format("{0}.json", productReport.ProductId));
using (FileStream file = File.Create(filePath))
{
using (StreamWriter writer = new StreamWriter(file))
{
writer.Write(jsonObject.ToString());
}
}
MongoProductReport mongoProductReport = new MongoProductReport
{
ProductId = productReport.ProductId,
ProductName = productReport.ProductName,
VendorName = productReport.VendorName,
TotalQuantitySold = productReport.SalesTotalQuantity,
TotalIncomes = productReport.SalesTotalSum
};
mongoProductsReports.Add(mongoProductReport);
}
}
mongo.InsertInMongoDB(mongoProductsReports, "ProductsReports");
}
public ServiceLogRepository(MongoDBManager _mongoDBManager)
{
MongoDBManager = _mongoDBManager;
}
public async Task <List <Movie> > GetRecommendedMovies(string userID)
{
MongoDBManager mm = new MongoDBManager();
List <Movie> movies = new List <Movie>();
Dictionary <string, int> genras = new Dictionary <string, int>();
UserInformation user = await mm.GetUserInformation(userID);
if (user == null)
{
return(movies);
}
/*foreach (var movieLike in user.MovieLikes) //get user favourite genra
* {
* var movie = mm.GetMovie(movieLike.Id);
* List<string> movieGenras = movie.Genre.Split(',').Select(x => x.Trim()).ToList();
*
* if (parameters.Valid(movieGenras))
* {
* movies.Add(movie);
* }
*
*
* }
* return movies;*/
foreach (var movieLike in user.MovieLikes)//get user favourite genra
{
var movie = await mm.GetMovie(movieLike.Id);
List <string> movieGenras = movie.Genres;
foreach (var movieGenra in movieGenras)
{
if (!genras.ContainsKey(movieGenra))
{
genras.Add(movieGenra, 0);
}
genras[movieGenra]++;
}
}
var max = genras.Values.Max();
string favouriteGenre = "";
foreach (var genre in genras.Keys)
{
if (genras[genre] == max)
{
favouriteGenre = genre;
break;
}
}
movies = mm.GetMoviesWithGenre(favouriteGenre);
List <Movie> moviesWithoutUserLiked = new List <Movie>();
foreach (var movie in movies)
{
bool exist = false;
foreach (var userLiked in user.MovieLikes)
{
if (userLiked.Id == movie.ID)
{
exist = true;
break;
}
}
if (!exist)
{
moviesWithoutUserLiked.Add(movie);
}
}
MoviesSort ms = new MoviesSort();
moviesWithoutUserLiked.Sort(ms);
return(moviesWithoutUserLiked);
}
/// <summary>
/// Method for extracting expenses reports in XML format
/// </summary>
/// <param name="filePath">Filepath for the .xml file</param>
public static void ReadVendorMonthlyExpenses(string filePath)
{
XmlReader reader = XmlReader.Create(filePath);
List<MongoVendorExpense> mongoVendorExpensesList = new List<MongoVendorExpense>();
using (var msSQLServerContext = new SupermarketEntities())
{
using (reader)
{
int vendorId = 0;
while (reader.Read())
{
//Insert a new vendor
if (reader.NodeType == XmlNodeType.Element && reader.Name == "sale")
{
string vendorName = reader.GetAttribute("vendor");
var vendor = msSQLServerContext.Vendors.FirstOrDefault(v => v.VendorName == vendorName);
if (vendor == null)
{
// the vendor doesn't exist
vendor = new Vendor
{
VendorName = vendorName
};
msSQLServerContext.Vendors.Add(vendor);
msSQLServerContext.SaveChanges();
}
vendorId = vendor.VendorId;
}
//Insert Expenses
if (reader.NodeType == XmlNodeType.Element && reader.Name == "expenses")
{
string month = reader.GetAttribute("month");
DateTime monthAsDate = DateTime.ParseExact(month, "MMM-yyyy", CultureInfo.InvariantCulture);
decimal amount = reader.ReadElementContentAsDecimal();
var vendorMonthlyExpense = new VendorExpense
{
VendorId = vendorId,
Month = monthAsDate.Month,
Year = monthAsDate.Year,
Amount = amount
};
var mongoVendorExpense = new MongoVendorExpense
{
VendorId = vendorId,
Month = monthAsDate.Month,
Year = monthAsDate.Year,
Amount = amount
};
mongoVendorExpensesList.Add(mongoVendorExpense);
msSQLServerContext.VendorExpenses.Add(vendorMonthlyExpense);
}
}
}
MongoDBManager<MongoVendorExpense> mongoDBInserter = new MongoDBManager<MongoVendorExpense>();
mongoDBInserter.InsertInMongoDB(mongoVendorExpensesList, "VendorExpenses");
msSQLServerContext.SaveChanges();
}
}
public AuditLogRepository(MongoDBManager _mongoDBManager)
{
MongoDBManager = _mongoDBManager;
}
public ExceptionLogRepository(MongoDBManager _mongoDBManager)
{
MongoDBManager = _mongoDBManager;
}
public async Task <List <Movie> > GetRecommendedMovies(string userID)
{
MongoDBManager mm = new MongoDBManager();
List <Movie> movies = new List <Movie>();
Dictionary <string, int> actors = new Dictionary <string, int>();
UserInformation user = await mm.GetUserInformation(userID);
if (user == null)
{
return(movies);
}
foreach (var movieLike in user.MovieLikes)//get user favourite genra
{
var movie = await mm.GetMovie(movieLike.Id);
List <string> movieActors = movie.Actors;
foreach (var movieActor in movieActors)
{
if (!actors.ContainsKey(movieActor))
{
actors.Add(movieActor, 0);
}
actors[movieActor]++;
}
}
var max = actors.Values.Max();
string favouriteActor = "";
foreach (var actor in actors.Keys)
{
if (actors[actor] == max)
{
favouriteActor = actor;
break;
}
}
movies = await mm.GetMoviesWithActor(favouriteActor);
List <Movie> moviesWithoutUserLiked = new List <Movie>();
foreach (var movie in movies)
{
bool exist = false;
foreach (var userLiked in user.MovieLikes)
{
if (userLiked.Id == movie.ID)
{
exist = true;
break;
}
}
if (!exist)
{
moviesWithoutUserLiked.Add(movie);
}
}
MoviesSort ms = new MoviesSort();
moviesWithoutUserLiked.Sort(ms);
return(moviesWithoutUserLiked);
}
