public PropertyController(IPropertyRepository repo, IMapper mapper, UserManager <User> userManager, DataContext context)
{
_mapper = mapper;
_userManager = userManager;
_context = context;
_repo = repo;
}
public ReservationController(IReservationRepository repository, IApartmentRepository apartmentRepo,
IPropertyRepository propertyRepo)
{
IReservationRepository = repository;
IApartmentRepository = apartmentRepo;
IPropertyRepository = propertyRepo;
}
public ActionResult Index()
{
this._propertyRepo = new PropertyRepository(new PropertyContext());
var temp = _propertyRepo.GetAllProperties();
return(View());
}
public CategoryService(ICategoryRepository categoryRepository, IPropertyRepository propertyRepository, IPropertyValueRepository propertyValueRepository, IProductRepository productRepository)
{
this._propertyRepository = propertyRepository;
this._categoryRepository = categoryRepository;
this._productRepository = productRepository;
this._propertyValueRepository = propertyValueRepository;
}
public ContractRepository(IPropertyRepository propertyRepository, ILesseeRepository lesseeRepository,
DataContext dataContext)
{
this.propertyRepository = propertyRepository;
this.lesseeRepository = lesseeRepository;
this.dataContext = dataContext;
}
public PropertyDataLoader(
IBatchScheduler batchScheduler,
IPropertyRepository propertyRepository)
: base(batchScheduler)
{
_propertyRepository = propertyRepository;
}
public IEnumerable <PropertyDTO> GetPropertiesByUser(Guid userId)
{
IEnumerable <Property> MyProperties = IPropertyRepository.GetPropertiesByUser(userId);
List <PropertyDTO> PropertiesDTO = new List <PropertyDTO>();
foreach (Property p in MyProperties)
{
PropertyDTO propertyDTO = new PropertyDTO()
{
id = p.id,
cityName = p.cityName,
name = p.name,
type = p.type,
description = p.description,
numberOfStars = p.numberOfStars,
street = p.street,
photo = p.photo,
userId = p.userId,
mapLatitude = p.mapLatitude,
mapLongitude = p.mapLongitude,
isPublic = p.isPublic
};
PropertiesDTO.Add(propertyDTO);
}
return(PropertiesDTO);
}
public OwnersController(IMapper mapper, IOwnerRepository ownerRepository, IPropertyRepository propertyRepository, IUnitOfWork unitOfWork)
{
this.mapper = mapper;
this.ownerRepository = ownerRepository;
this.propertyRepository = propertyRepository;
this.unitOfWork = unitOfWork;
}
public IEnumerable <PropertyDTO> GetAvailableProperties(string searchText, DateTime checkin, DateTime checkout, int persons)
{
IEnumerable <Property> availableProperties = IPropertyRepository.GetAvailableProperties(searchText, checkin, checkout, persons);
List <PropertyDTO> PropertiesDTO = new List <PropertyDTO>();
foreach (Property p in availableProperties)
{
PropertyDTO propertyDTO = new PropertyDTO()
{
id = p.id,
cityName = p.cityName,
name = p.name,
type = p.type,
description = p.description,
numberOfStars = p.numberOfStars,
street = p.street,
photo = p.photo,
userId = p.userId,
mapLatitude = p.mapLatitude,
mapLongitude = p.mapLongitude,
isPublic = p.isPublic
};
if (propertyDTO.isPublic == true)
{
int numberOfReservations = 0;
int allRatings = 0;
List <Apartment> apartments = IApartmentRepository.GetAll().Where(x => x.propertyId == propertyDTO.id).ToList();
int minimumPrice = apartments[0].pricePerNight;
foreach (Apartment ap in apartments)
{
if (ap.pricePerNight < minimumPrice)
{
minimumPrice = ap.pricePerNight;
}
IEnumerable <Reservation> reservations = IReservationRepository.GetAll().Where(x => x.apartmentId == ap.id);
foreach (Reservation res in reservations)
{
if (res.rating != 0)
{
allRatings += res.rating;
numberOfReservations++;
}
}
}
if (minimumPrice != 0)
{
propertyDTO.startingPrice = minimumPrice;
}
if (numberOfReservations != 0)
{
float average = (float)allRatings / (float)numberOfReservations;
propertyDTO.averageRating = average;
}
PropertiesDTO.Add(propertyDTO);
}
}
return(PropertiesDTO);
}
public PropertyService(IPropertyRepository propertyRepository, INotifyPartiesService notifyPartiesService, IUserAuthorizationService authorizationService)
{
_propertyRepository = propertyRepository;
_notifyPartiesService = notifyPartiesService;
_authService = authorizationService;
//_claimService = authorizationService.LoggedUser;
}
public List <ApartmentDTO> GetAvailableApartments(Guid propertyId, DateTime checkin, DateTime checkout, int persons)
{
IEnumerable <Apartment> availableApartments = IPropertyRepository.GetAvailableApartments(propertyId, checkin, checkout, persons);
List <ApartmentDTO> ApartmentsDTO = new List <ApartmentDTO>();
foreach (Apartment ap in availableApartments)
{
IEnumerable <Photo> Photos = IPhotoRepository.GetAll().Where(x => x.apartmentId == ap.id);
if (Photos != null)
{
List <string> PhotosPathsList = new List <string>();
foreach (Photo Photo in Photos)
{
PhotosPathsList.Add(Photo.path);
}
ApartmentDTO apartmentDTO = new ApartmentDTO()
{
id = ap.id,
apartmentName = ap.apartmentName,
numberOfRooms = ap.numberOfRooms,
description = ap.description,
pricePerNight = ap.pricePerNight,
maxPersons = ap.maxPersons,
propertyId = ap.propertyId,
photos = PhotosPathsList
};
ApartmentsDTO.Add(apartmentDTO);
}
}
return(ApartmentsDTO);
}
public Property Put(int id, PropertyDTO value)
{
Property model = IPropertyRepository.Get(id);
if (value.type != null)
{
model.type = value.type;
}
if (value.description != null)
{
model.description = value.description;
}
if (value.numberOfStars != 0)
{
model.numberOfStars = value.numberOfStars;
}
if (value.street != null)
{
model.street = value.street;
}
if (value.streetNumber != 0)
{
model.streetNumber = value.streetNumber;
}
if (value.photo != null)
{
model.photo = value.photo;
}
return(IPropertyRepository.Update(model));
}
public TransactionService(ITransactionRepository transactionRepository, IPropertyRepository propertyRepository, IUnitOfWork unitOfWork, ITransactionValidator transactionValidator)
{
_transactionRepository = transactionRepository;
_propertyRepository = propertyRepository;
_unitOfWork = unitOfWork;
_transactionValidator = transactionValidator;
}
public ModelPropertyService(IMapper mapper, IClassRepository classRepository, IModelPropertyRepository repository, IPropertyRepository propertyRepository)
{
_mapper = mapper;
_classRepository = classRepository;
_repository = repository;
_propertyRepository = propertyRepository;
}
public void Initialize()
{
// Initialize the data we're going to use in the tests
_propertyListMock = PropertyMocks.GetPropertyListMock();
// First we neet to mock the DbSet
_propertyDbSetMock = new Mock <DbSet <Property> >();
// Since we're faking the db context with async methods, we need to set up a few things
_propertyDbSetMock.As <IDbAsyncEnumerable <Property> >()
.Setup(m => m.GetAsyncEnumerator())
.Returns(new TestDbAsyncEnumerator <Property>(_propertyListMock.AsQueryable().GetEnumerator()));
_propertyDbSetMock.As <IQueryable <Property> >()
.Setup(m => m.Provider)
.Returns(new TestDbAsyncQueryProvider <Property>(_propertyListMock.AsQueryable().Provider));
_propertyDbSetMock.As <IQueryable <Property> >().Setup(m => m.Expression).Returns(_propertyListMock.AsQueryable().Expression);
_propertyDbSetMock.As <IQueryable <Property> >().Setup(m => m.ElementType).Returns(_propertyListMock.AsQueryable().ElementType);
_propertyDbSetMock.As <IQueryable <Property> >().Setup(m => m.GetEnumerator()).Returns(_propertyListMock.AsQueryable().GetEnumerator());
// Now we can mock the entire context
_realStateContextMock = new Mock <IRealStateContext>();
_realStateContextMock.Setup(context => context.Properties).Returns(_propertyDbSetMock.Object);
// Initialize the repository with the mocked dbContext
_propertyRepositoryMock = new PropertyRepository(_realStateContextMock.Object);
}
public ChatHandler(IPlayerHandler playerHandler, IPropertyRepository propertyRepository)
{
this.playerHandler = playerHandler;
this.propertyRepository = propertyRepository;
this.chatMessages = propertyRepository.Load <List <ChatMessage> >(nameof(chatMessages)) ??
new List <ChatMessage>();
}
/*
* public IEnumerable<Reservation> GetReservationsByUser(int userId)
* {
* return IReservationRepository.GetReservationsByUser(userId);
* }
*/
public IEnumerable <ReservationDTO> GetReservationsByUser(int userId)
{
IEnumerable <Reservation> MyReservations = IReservationRepository.GetReservationsByUser(userId);
List <ReservationDTO> ReservationsDTO = new List <ReservationDTO>();
foreach (Reservation r in MyReservations)
{
ReservationDTO reservationDTO = new ReservationDTO()
{
id = r.id,
checkIn = r.checkIn,
checkOut = r.checkOut,
price = r.price,
review = r.review,
userId = r.userId,
apartmentId = r.apartmentId,
numberOfPersons = r.numberOfPersons
};
ReservationsDTO.Add(reservationDTO);
}
foreach (ReservationDTO res in ReservationsDTO)
{
Apartment Apartment = IApartmentRepository.Get(res.apartmentId);
res.apartmentName = Apartment.apartmentName;
Property Property = IPropertyRepository.Get(Apartment.propertyId);
res.propertyName = Property.name;
res.propertyId = Property.id;
}
return(ReservationsDTO);
}
public PropertyService(IMapper mapper, IPropertyRepository repository, IClassRepository classRepository, CodeGeneratorDbContext dbContext)
{
_mapper = mapper;
_repository = repository;
_classRepository = classRepository;
_dbContext = dbContext;
}
public PropertyController(IConstantRepository ConstantParam, IMemberRepository MemberParam, IPropertyRepository PropertyParam, IMinistryRepository MinistryParam)
{
ConstantRepository = ConstantParam;
MemberRepository = MemberParam;
PropertyRepository = PropertyParam;
MinistryRepository = MinistryParam;
ViewBag.Supervisor = false;
int memberID = Convert.ToInt16(System.Web.HttpContext.Current.Session["personID"]);
if (memberID > 0)
{
if (MembershipRepositroy.IsUser(memberID))
{
user user = MembershipRepositroy.GetUserByID(memberID);
if ((user.role.Name == "WebMaster") || (user.role.Name == "Pastor") || (user.role.Name == "Admin") || (user.role.Name == "Admin2")) //creator access
{
ViewBag.Supervisor = true;
}
if (user.role.Name == "WebMaster") //creator access
{
ViewBag.WebMaster = true;
}
if (user.role.Name == "Officer") //creator access
{
ViewBag.Supervisor2 = true;
}
}
}
}
public PropertiesController(IPropertyRepository propertyRepository,
IAddressRepository addressRepository, IOwnerRepository ownerRepository)
{
_propertyRepository = propertyRepository;
_addressRepository = addressRepository;
_ownerRepository = ownerRepository;
}
public ResearchFileService(ClaimsPrincipal user, ILogger <ResearchFileService> logger, IResearchFileRepository researchFileRepository, IPropertyRepository propertyRepository)
{
_user = user;
_logger = logger;
_researchFileRepository = researchFileRepository;
_propertyRepository = propertyRepository;
}
public TransactionApp(ITransactionRepository transactionRepository, IAccountRepository accountRepository, ICategoryRepository categoryRepository, IPropertyRepository propertyRepository)
{
_transactionRepository = transactionRepository;
_accountRepository = accountRepository;
_categoryRepository = categoryRepository;
_propertyRepository = propertyRepository;
}
public PropertyService(IMapper mapper, IPropertyRepository repository, IClassRepository classRepository, IUnitOfWork <CodeGeneratorDbContext> uow)
{
_mapper = mapper;
_repository = repository;
_classRepository = classRepository;
_uow = uow;
}
public PropertyServices(IPropertyRepository propertyRepository, IRepository<PropertyAddress> propertyAddress,
IRepository<PropertyFacility> proeprtyFacility, IRepository<PropertyFeature> propertyFeature )
{
_propertyRepository = propertyRepository;
_propertyAddress = propertyAddress;
_proeprtyFacility = proeprtyFacility;
_propertyFeature = propertyFeature;
}
public PropertyService(IPropertyRepository propertyRepository, ICommentRepository commentRepository, IUnitOfWork unitOfWork, IPropertyValidator propertyValidator, IIdentityService identityService)
{
_propertyRepository = propertyRepository;
_commentRepository = commentRepository;
_unitOfWork = unitOfWork;
_propertyValidator = propertyValidator;
_identityService = identityService;
}
public ClassService(IMapper mapper, IClassRepository repository, BaseEntityPropertyCollection baseEntityPropertyCollection, IPropertyRepository propertyRepository, IClassMethodRepository classMethodRepository)
{
_mapper = mapper;
_repository = repository;
_baseEntityPropertyCollection = baseEntityPropertyCollection;
_propertyRepository = propertyRepository;
_classMethodRepository = classMethodRepository;
}
public ObjectDirector(IRequestHandler requestHandler)
{
this.requestHandler = requestHandler;
this.classRepository = this.requestHandler.Storage.GetRepository <IClassRepository>();
this.memberRepository = this.requestHandler.Storage.GetRepository <IMemberRepository>();
this.propertyRepository = this.requestHandler.Storage.GetRepository <IPropertyRepository>();
this.localizationRepository = this.requestHandler.Storage.GetRepository <ILocalizationRepository>();
}
public UserController(IUserRepository repository, IApartmentRepository apRepository, IPropertyRepository propRepository,
IReservationRepository resRepository)
{
IUserRepository = repository;
IApartmentRepository = apRepository;
IPropertyRepository = propRepository;
IReservationRepository = resRepository;
}
public SecurityRoleAdminService(ILogger <SecurityRoleAdminService> logger,
IRoleRepository roleRepository,
IPropertyRepository propertyRepository)
{
_logger = logger;
_roleRepository = roleRepository;
_propertyRepository = propertyRepository;
}
public ModuleAdminService(ILogger <ModuleAdminService> logger,
IModuleRepository moduleRepository,
IPropertyRepository propertyRepository)
{
_logger = logger;
_moduleRepository = moduleRepository;
_propertyRepository = propertyRepository;
}
public Property PutAvailability(Guid id, PropertyDTO value)
{
Property model = IPropertyRepository.Get(id);
model.isPublic = value.isPublic;
return(IPropertyRepository.Update(model));
}
public PropertyService(IPropertyRepository propertyRepository,
IOwnerService ownerService,
IMapper mapper)
{
_propertyRepository = propertyRepository;
_ownerService = ownerService;
_mapper = mapper;
}
public GangsterBankUnitOfWork(
IRepository<Account> accountsRepository,
IRepository<Address> addressesRepository,
ICitiesRepository citiesRepository,
IClientsRepository clientsRepository,
IContactsRepository contactsRepository,
ICountriesRepository countryRepository,
IEmploymentDataRepository employmentDataRepository,
ILoanProductsRepository loanProductsRepository,
IObligationRepository obligationsRepository,
IPassportDataRepository passportDataRepository,
IPropertyRepository propertiesRepository,
IPersonalDetailsRepository personalDetailsRepository,
ILoanRequestsRepository loanRequestsRepository,
IRolesRepository roles,
IRepository<LoanProductRequirements> loanProductsRequirmentsRepository,
IRepository<TakenLoan> takenLoansRepository,
IRepository<Payment> paymentsRepository,
ILoanPaymentsRepository loanPaymentsRepository)
{
Contract.Requires<ArgumentNullException>(accountsRepository.IsNotNull());
Contract.Requires<ArgumentNullException>(addressesRepository.IsNotNull());
Contract.Requires<ArgumentNullException>(citiesRepository.IsNotNull());
Contract.Requires<ArgumentNullException>(clientsRepository.IsNotNull());
Contract.Requires<ArgumentNullException>(contactsRepository.IsNotNull());
Contract.Requires<ArgumentNullException>(countryRepository.IsNotNull());
Contract.Requires<ArgumentNullException>(employmentDataRepository.IsNotNull());
Contract.Requires<ArgumentNullException>(loanProductsRepository.IsNotNull());
Contract.Requires<ArgumentNullException>(obligationsRepository.IsNotNull());
Contract.Requires<ArgumentNullException>(passportDataRepository.IsNotNull());
Contract.Requires<ArgumentNullException>(propertiesRepository.IsNotNull());
Contract.Requires<ArgumentNullException>(personalDetailsRepository.IsNotNull());
Contract.Requires<ArgumentNullException>(loanRequestsRepository.IsNotNull());
Contract.Requires<ArgumentNullException>(roles.IsNotNull());
Contract.Requires<ArgumentNullException>(loanProductsRequirmentsRepository.IsNotNull());
Contract.Requires<ArgumentNullException>(takenLoansRepository.IsNotNull());
Contract.Requires<ArgumentNullException>(paymentsRepository.IsNotNull());
Contract.Requires<ArgumentNullException>(loanPaymentsRepository.IsNotNull());
this.AccountsRepository = accountsRepository;
this.AddressesRepository = addressesRepository;
this.CitiesRepository = citiesRepository;
this.ClientsRepository = clientsRepository;
this.ContactsRepository = contactsRepository;
this.CountryRepository = countryRepository;
this.EmploymentDataRepository = employmentDataRepository;
this.LoanProductsRepository = loanProductsRepository;
this.ObligationsRepository = obligationsRepository;
this.PassportDataRepository = passportDataRepository;
this.PropertiesRepository = propertiesRepository;
this.PersonalDetailsRepository = personalDetailsRepository;
this.LoanRequestsRepository = loanRequestsRepository;
this.RolesRepository = roles;
this.LoanProductsRequirmentsRepository = loanProductsRequirmentsRepository;
this.TakenLoansRepository = takenLoansRepository;
this.PaymentsRepository = paymentsRepository;
this.LoanPaymentsRepository = loanPaymentsRepository;
}
public PropertyService(ICache<Dictionary<string, object>> cache, IPropertyRepository propertyRepository)
{
_cache = cache;
_propertyRepository = propertyRepository;
_propertyDictionary = _cache.Get(_key);
if (_propertyDictionary == null)
{
InitializeCache();
}
}
public PropertyService(IPropertyRepository propertyService, ILandlordRepository landlordRepository,
IPropertySubmissionRepository propertySubmissionRepository, IReferenceGenerator referenceGenerator)
{
Check.If(propertyService).IsNotNull();
Check.If(landlordRepository).IsNotNull();
Check.If(propertySubmissionRepository).IsNotNull();
Check.If(referenceGenerator).IsNotNull();
_propertyRepository = propertyService;
_landlordRepository = landlordRepository;
_propertySubmissionRepository = propertySubmissionRepository;
_referenceGenerator = referenceGenerator;
}
public SyncController()
{
#if DEBUG
IRepositoryFactory repositoryFactory = new MemoryRepositoryFactory();
DataBaseFiller.FillSampleData(repositoryFactory);
#else
IRepositoryFactory repositoryFactory = new RepositoryFactory();
#endif
_propertyRepository = repositoryFactory.GetPropertyRepository();
_accountRepository = repositoryFactory.GetAccountRepository();
_categoryRepository = repositoryFactory.GetCategoryRepository();
_transactionRepository = repositoryFactory.GetTransactionRepository();
_userRepository = repositoryFactory.GetUserRepository();
}
public PropertyService(IPropertyRepository propertyRepository,
IReferenceGenerator referenceGenerator,
IStatusGeneratorFactory statusGeneratorFactory,
IPropertyServiceClient propertyServiceClient,
IApplicationService applicationService, IPipelinePositionGenerator pipelinePositionGenerator)
{
Check.If(propertyRepository).IsNotNull();
Check.If(referenceGenerator).IsNotNull();
Check.If(statusGeneratorFactory).IsNotNull();
Check.If(propertyServiceClient).IsNotNull();
Check.If(applicationService).IsNotNull();
_propertyRepository = propertyRepository;
_referenceGenerator = referenceGenerator;
_statusGeneratorFactory = statusGeneratorFactory;
_propertyServiceClient = propertyServiceClient;
_applicationService = applicationService;
_pipelinePositionGenerator = pipelinePositionGenerator;
}
public PropertyService()
{
_repository = DependencyManager.Resolve<IPropertyRepository>();
}
public PropertyImportController(IPropertyRepository repository, IPropertyFileReader fileReader)
{
_repository = repository;
_fileReader = fileReader;
}
public PropertyImportController()
{
_repository = IocContainer.Instance.Get<IPropertyRepository>();
}
public PropertyManager(IPropertyRepository propertyRepository, IAddressRepository addressRepository)
{
_propertyRepository = propertyRepository;
_addressRepository = addressRepository;
}
public UserApp(IUserRepository userRepository, IPropertyRepository propertyRepository)
{
_userRepository = userRepository;
_propertyRepository = propertyRepository;
}
public IPropertyRepository GetPropertyRepository()
{
PropertyRepository = PropertyRepository ?? new PropertyRepository(Db);
return PropertyRepository;
}
public PropertyService(IPropertyRepository propertyRepository)
{
this._propertyRepository = propertyRepository;
}
public CategoryApp(ICategoryRepository categoryRepository, IPropertyRepository propertyRepository, ITransactionRepository transactionRepository)
{
_categoryRepository = categoryRepository;
_propertyRepository = propertyRepository;
_transactionRepository = transactionRepository;
}
public PropertyService(IPropertyRepository propertyRepository)
{
_propertyRepository = propertyRepository ?? new PropertyRepository();
}
public void Setup()
{
_mockDbSettings.Setup(x => x.ConnectionString).Returns("TestConectionString");
_mockContext.Setup(x => x.Properties).Returns(_mockPropertyDbSet.Object);
_mockContext.Setup(x => x.Landlords).Returns(_mockLandlordDbSet.Object);
_mockContext.Setup(x => x.SaveChanges()).Returns(1);
_mockPropertyMapper.Setup(x => x.Map(It.IsAny<Property>(), It.IsAny<Property>())).Returns(true);
_propertyRepository = new PropertyRepository(_mockContext.Object, _mockPropertyMapper.Object);
}
public PropertyService(IPropertyRepository repository)
{
_repository = repository;
}
public AccountApp(IAccountRepository accountRepository, IPropertyRepository propertyRepository, ITransactionRepository transactionRepository)
{
_accountRepository = accountRepository;
_propertyRepository = propertyRepository;
_transactionRepository = transactionRepository;
}
public PropertyController()
{
repository = new PropertyRepository();
commons = new CommonRepository();
agentRepository = new AgentRepository();
}
public CaselistService(IPropertyRepository propertyRepository)
{
_propertyRepository = propertyRepository;
}
