public HomeController(
IReviewRepository reviewRepository,
IDateTime now)
{
_reviewRepository = reviewRepository;
_now = now;
}
public ActController(IReviewRepository newRepository, IPendingRepository newPendingRepository,
IMessageRepository newMessageRepository)
{
repository = newRepository;
pendingRepository = newPendingRepository;
messagesRepository = newMessageRepository;
}
public ReviewService(IReviewRepository reviewRepository, IPictureService pictureService, IPictureRepository pictureRepository, IReviewLinkRepository reviewLinkRepository)
{
this.ReviewRepository = reviewRepository;
this.PictureService = pictureService;
this.PictureRepository = pictureRepository;
this.ReviewLinkRepository = reviewLinkRepository;
}
public ReviewRepositoryTest()
{
var fake = A.Fake<IEnvironmentPathProvider>();
A.CallTo(() => fake.GetImageCachePath()).Returns(ImageCache);
_reviewRepository = new ReviewRepository(new AlephRepository(fake));
}
public ProductController(IManafacturerRepository manafacturerRepository, IProductRepository productRepository,
IReviewRepository reviewReporistory, ISubmitterRepository submitterRepository)
{
_manafacturerRepository = manafacturerRepository;
_productRepository = productRepository;
_reviewRepository = reviewReporistory;
_submitterRepository = submitterRepository;
}
public DocumentController(IRepository documentRepository, ISuggestionDictionary suggestionRepository, IImageRepository imageRepository, IRatingRepository ratingRepository, IReviewRepository reviewRepository)
{
_documentRepository = documentRepository;
_suggestionRepository = suggestionRepository;
_imageRepository = imageRepository;
_ratingRepository = ratingRepository;
_reviewRepository = reviewRepository;
}
public DocumentModule(IRepository documents, IImageRepository images, IRatingRepository ratings, IReviewRepository reviews, IFavoritesRepository favorites, IEnvironmentPathProvider pathProvider)
: base("/documents")
{
Get["/{id}/thumbnail"] = args =>
{
var doc = documents.GetDocument(args.id, true);
string img = images.GetDocumentImage(args.id);
if (String.IsNullOrEmpty(img))
{
return ResolvePlaceHolderImageForDocumentType(pathProvider, doc);
}
return Response.AsFile(Path.Combine(pathProvider.GetImageCachePath(), img));
};
Get["/{id}"] = args =>
{
Document document = documents.GetDocument(args.id, false);
return Response.AsJson(DtoMaps.Map(document, favorites, Context.GetUserInfo()));
};
Get["/{id}/rating"] = args =>
{
try
{
DocumentRating rating = ratings.GetDocumentRating(args.id);
return Response.AsJson(new DocumentRatingDto
{
MaxScore = rating.MaxScore,
Score = rating.Score,
Source = rating.Source,
SourceUrl = rating.SourceUrl,
HasRating = true
}).AsCacheable(DateTime.Now.AddDays(1));
}
catch
{
return new DocumentRatingDto {Success = true, HasRating = false};
}
};
Get["/{id}/review"] = args =>
{
string review = reviews.GetDocumentReview(args.id);
return Response.AsJson(new DocumentReviewDto{ Review = review, Url = "" }).AsCacheable(DateTime.Now.AddDays(1));
};
Get["/search"] = _ =>
{
string query = Request.Query.query.HasValue ? Request.Query.query : null;
if (null == query) throw new InvalidOperationException("Ingenting å søke etter.");
return Response.AsJson(documents.Search(query).Select(doc => DtoMaps.Map(doc, favorites, Context.GetUserInfo())).ToArray()).AsCacheable(DateTime.Now.AddHours(12));
};
}
public AdminController(IReviewRepository newRepository, IPendingRepository newPendingRepository,
IMessageRepository newMessageRepository)
{
repository = newRepository;
pendingRepository = newPendingRepository;
messageRepository = newMessageRepository;
//token = "184dfc1425358c1ec4c9fbb3787e59db84e66a4e133ff20376d0dde52ddcec8c657279f7117be6880397b";
token = "cf54ae77fdfba85e3e141c865552d916191a636d0dd682b6472f3ba2a1b9883cecae7e2f7dab7273afcd3";
}
public ReviewController(
IMovieRepository movieRepository,
IReviewRepository reviewRepository,
ICurrentUser currentUser,
IReviewerGenreRepository reviewerGenreRepository)
{
_movieRepository = movieRepository;
_reviewRepository = reviewRepository;
_currentUser = currentUser;
_reviewerGenreRepository = reviewerGenreRepository;
}
public DocumentModuleTests()
{
_documentRepository = A.Fake<IRepository>();
_imageRepository = A.Fake<IImageRepository>();
_ratingRepository = A.Fake<IRatingRepository>();
_reviewRepository = A.Fake<IReviewRepository>();
_pathProvider = A.Fake<IEnvironmentPathProvider>();
_browser = new Browser(with =>
{
with.Module<DocumentModule>();
with.Dependency(_documentRepository);
with.Dependency(_imageRepository);
with.Dependency(_ratingRepository);
with.Dependency(_reviewRepository);
with.Dependency(_pathProvider);
with.Dependency(A.Fake<IFavoritesRepository>());
});
}
public ReviewApiController(IReviewRepository reviewRepository, IMediator mediator)
{
_reviewRepository = reviewRepository;
_mediator = mediator;
}
public ProgrammesController(IProgrammeRepository programmeRepository, IFacultyRepository facultyRepository, IReviewRepository reviewRepository)
{
_programmeRepository = programmeRepository;
_facultyRepository = facultyRepository;
_reviewRepository = reviewRepository;
}
public ReviewersController(IReviewerRepository reviewerRepo, IReviewRepository reviewRepo)
{
_reviewerRepo = reviewerRepo;
_reviewRepo = reviewRepo;
}
public ReviewController(IReviewRepository reviewRepo)
{
reviewRepository = reviewRepo;
}
public RecipeController(IReviewRepository reviewRepository,
IUserProfileEntityFactory userProfileEntityFactory)
{
this._reviewRepository = reviewRepository;
this._userProfileEntityFactory = userProfileEntityFactory;
}
public static int GetMoviePopularity(int idMovie, IMovieDataRepository movieDataRepository, IReviewRepository reviewRepository)
{
if (idMovie <= 0)
{
return(0);
}
int score = 0;
if (ScoreHelper.isFromThisYear(idMovie, movieDataRepository))
{
score += 20;
}
if (ScoreHelper.isPlataformFavorite(idMovie, movieDataRepository))
{
score += 20;
}
score += ScoreHelper.reviewsScore(idMovie, reviewRepository);
return(score);
}
public GetReviewForProduct(IReviewRepository repository)
{
Repository = repository;
}
public MovieRecommender(IUnitOfWork unit, PredictionEnginePool <MovieRating, MovieRatingPrediction> predictionEnginePool)
{
_unit = unit;
_reviewRepo = _unit.Reviews;
_predictionEnginePool = predictionEnginePool;
}
public ReviewReadService(IReviewRepository reviewRepository, IMapper mapper)
{
_reviewRepository = reviewRepository;
_mapper = mapper;
}
/// <summary>
/// Initializes a new instance of the <see cref="CatalogItemPartitionCreator" /> class.
/// </summary>
/// <param name="repository">The repository.</param>
/// <param name="logRepository">The log repository.</param>
/// <param name="reviewRepository">The review repository.</param>
public CatalogItemPartitionCreator(ICatalogRepository repository, IOperationLogRepository logRepository, IReviewRepository reviewRepository)
{
_catalogRepository = repository;
_logRepository = logRepository;
_reviewRepository = reviewRepository;
}
private void RefreshRepository(ref IReviewRepository client)
{
client.Dispose();
client = null;
GC.Collect();
client = GetRepository();
}
public ReviewsController(IReviewRepository reviewRepository, ICategoriesRepository categoriesRepository)
{
_reviewRepository = reviewRepository;
_categoriesRepository = categoriesRepository;
}
public ReviewService(IReviewRepository repository)
{
this.repository = repository;
}
public HomeController(IReviewRepository newRepository, int itemsPerPage = 10)
{
repository = newRepository;
_itemsPerPage = itemsPerPage;
}
public ReviewClient(IReviewRepository reviewRepository, ICacheRepository cacheRepository)
{
_reviewRepository = reviewRepository;
_cacheRepository = cacheRepository;
_isEnabled = ReviewConfiguration.Instance.Cache.IsEnabled;
}
public ReviewersController(IReviewerRepository reviewerRepository, IReviewRepository reviewRepository)
{
_reviewerRepository = reviewerRepository;
_reviewRepository = reviewRepository;
}
public void InitRepository()
{
_reviewRepository = new ReviewRepository(new AlephRepository(ImageCache));
}
public BusinessLogicReviews(IReviewRepository reviewRepository)
{
_reviewRepository = reviewRepository;
}
public static int GetRecommendationScore(Resources.UserPoints points, Resources.Movie movie, IMovieDataRepository movieDataRepository, IReviewRepository reviewRepository)
{
int imdb = movie.Imdb.GetValueOrDefault();
int ms = movie.MetaScore.GetValueOrDefault();
int com = ScoreHelper.GetMovieCommunityScore(movie.IdMovie.Value, reviewRepository);
int platFav = 0;
int pop = ScoreHelper.GetMoviePopularity(movie.IdMovie.Value, movieDataRepository, reviewRepository);
if (movie.PlatFav)
{
platFav = 100;
}
int score = (imdb * points.Imdb / 100) + (ms * points.MetaScore / 100) + (com * points.Community / 100) + (platFav * points.PlatFav / 100)
+ (pop * points.Popularity / 100);
return(score);
}
public ReviewCommandService(IReviewRepository reviewRepository, IMapper mapper, IReviewReadService reviewReadService)
{
_reviewRepository = reviewRepository;
_mapper = mapper;
_reviewReadService = reviewReadService;
}
public ReviewManager(IReviewRepository reivewRepository)
{
this._reivewRepository = reivewRepository;
}
public ReviewController(UserManager <IdentityUser> userManager, IReviewRepository reviewRepository)
{
_userManager = userManager;
_reviewRepository = reviewRepository;
}
public IEnumerable <Review> GetReviews(
Episode episode,
[Service] IReviewRepository repository) =>
repository.GetReviews(episode);
/// <summary>
/// Initializes a new instance of the <see cref="ReviewController" /> class.
/// </summary>
/// <param name="reviewRepository">The review repository.</param>
/// <param name="reviewClient">The review client.</param>
/// <param name="orderClient">The order client.</param>
public ReviewController(IReviewRepository reviewRepository, ReviewClient reviewClient, OrderClient orderClient)
{
_repository = reviewRepository;
_reviewClient = reviewClient;
_orderClient = orderClient;
}
public CompanyController(ICompanyRepository companyRepository, IProductRepository productRepository, IReviewRepository reviewRepository, ICategoryRepository categoryRepository)
{
_companyRepository = companyRepository;
_productRepository = productRepository;
_reviewRepository = reviewRepository;
_categoryRepository = categoryRepository;
}
public ReviewManager(IReviewRepository reviewRepo)
{
ReviewRepo = reviewRepo;
}
public ReviewsController(IReviewRepository reviewRepository, ICategoriesRepository categoriesRepository)
{
_reviewRepository = reviewRepository;
_categoriesRepository = categoriesRepository;
}
/// <summary>
/// Creates a RecipeInput object from the recipeID received as parameter
/// </summary>
/// <param name="recipeID"></param>
/// <param name="recipeRepository"></param>
/// <param name="ingredientRepository"></param>
/// <param name="recipe_ingredientRepository"></param>
/// <returns></returns>
public static RecipeInput convertIntoRecipeInput(int recipeID, IRecipeRepository recipeRepository, IIngredientRepository ingredientRepository, IRecipe_IngredientRepository recipe_ingredientRepository, IReviewRepository reviewRepository)
{
Recipe recipe;
recipe = recipeRepository.RecipeList
.FirstOrDefault(r => r.RecipeID == recipeID);
RecipeInput recipeInput = new RecipeInput {
};
Ingredient ingredient = new Ingredient();
IngredientInput ingredientInput;
Review review;
recipeInput.RecipeID = recipeID;
recipeInput.Title = recipe.Title;
recipeInput.TotalTime = recipe.TotalTime;
recipeInput.CookTime = recipe.CookTime;
recipeInput.Instructions = recipe.Instructions;
recipeInput.Category = recipe.Category;
foreach (Recipe_Ingredient ri in recipe_ingredientRepository.Recipe_IngredientList
.Where(r => r.RecipeID == recipeID))
{
ingredientInput = new IngredientInput
{
IngredientID = ri.IngredientID,
Name = ingredientRepository.Ingredients
.FirstOrDefault(i => i.IngredientID == ri.IngredientID).Name,
Quantity = ri.Quantity,
UnitOfMeasurement = ri.UnitOfMeasurement
};
recipeInput.Ingredients.Add(ingredientInput);
}
foreach (Review rev in reviewRepository.Reviews
.Where(r => r.RecipeID == recipeID))
{
review = new Review
{
Rating = rev.Rating,
Comments = rev.Comments
};
recipeInput.Reviews.Add(review);
}
return(recipeInput);
}
public ReviewsController(IReviewerRepository reviewerRepository, IReviewRepository reviewRepository, IBookRepository bookRepository)
{
_reviewerRepository = reviewerRepository;
_reviewRepository = reviewRepository;
_bookRepository = bookRepository;
}
public ReviewServices(IReviewRepository repo)
{
_repo = repo;
}
public ReviewsControllerTests()
{
reviewRepo = Substitute.For <IReviewRepository>();
underTest = new ReviewsController(reviewRepo);
}
public ReviewsController(IItemRepository repoItem, IStoreRepository repoStore, IOrderRepository repoOrd, ITopicOptionRepository repoTopi, ISellerRepository repoSell, IPersonRepository repoPers, IReviewRepository repoRev)
{
RepoItem = repoItem ?? throw new ArgumentNullException(nameof(repoItem));
RepoStore = repoStore ?? throw new ArgumentNullException(nameof(repoStore));
RepoOrd = repoOrd ?? throw new ArgumentNullException(nameof(repoOrd));
RepoTopi = repoTopi ?? throw new ArgumentNullException(nameof(repoTopi));
RepoSell = repoSell ?? throw new ArgumentNullException(nameof(repoSell));
RepoPers = repoPers ?? throw new ArgumentNullException(nameof(repoPers));
RepoRev = repoRev ?? throw new ArgumentNullException(nameof(repoRev));
}
public ReviewController()
{
this.reviewRepository = new ReviewRepository(new Entities());
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="reviewrepository"></param>
public ReviewService(IReviewRepository reviewrepository)
{
this._reviewrepository = reviewrepository;
}
public BooksController(IBookRepository bookRepository, IAuthorRepository authorRepository, ICategoryRepository categoryRepository, IReviewRepository reviewRepository)
{
_bookRepository = bookRepository;
_authorRepository = authorRepository;
_categoryRepository = categoryRepository;
_reviewRepository = reviewRepository;
}
public RecipeController(IRecipeRepository recipes, IIngredientRepository ingredients, IRecipe_IngredientRepository recipes_ingredients, IReviewRepository reviews)
{
recipeRepository = recipes;
ingredientRepository = ingredients;
recipe_ingredientRepository = recipes_ingredients;
reviewRepository = reviews;
}
public ReviewController(IReviewRepository reviewRepo)
{
this.reviewRepo = reviewRepo;
}
public ReviewService(IReviewRepository reviewRepository)
{
_reviewRepository = reviewRepository;
}
public ReviewController()
{
_reviewRepository = Factory.GetReviewRepository();
_foodieRepository = Factory.GetFoodieRepository();
}
public ReviewsController(IReviewRepository reviewRepository, UserManager <User> userManager, IMapper mapper)
: base(mapper)
{
this.reviewRepository = reviewRepository;
this.userManager = userManager;
}
public HomeController(ICategoriesRepository categoriesRepository, IReviewRepository reviewRepository)
{
_categoriesRepository = categoriesRepository;
_reviewRepository = reviewRepository;
}
public ReviewController(IMovieRepository movieRepository, IUserRepository userRepository, IReviewRepository reviewRepository)
{
this.movieRepository = movieRepository;
this.userRepository = userRepository;
this.reviewRepository = reviewRepository;
}
