public PersonService(
IPersonRepository personRepository,
IPersonGroupRepository personGroupRepository,
IPermissionRepository permissionRepository,
IPersonRoleRepository personRoleRepository,
IPersonOptionalFieldRepository personOptionalFieldRepository,
IRelationshipRepository relationshipRepository,
IChurchMatcherRepository churchMatcherRepository,
IGroupRepository groupRepository,
IFamilyRepository familyRepository,
IEmailService emailService,
IAddressRepository addressRepository,
IPhotoRepository photoRepository)
{
_personRepository = personRepository;
_personGroupRepository = personGroupRepository;
_permissionRepository = permissionRepository;
_personRoleRepository = personRoleRepository;
_personOptionalFieldRepository = personOptionalFieldRepository;
_relationshipRepository = relationshipRepository;
_churchMatcherRepository = churchMatcherRepository;
_groupRepository = groupRepository;
_familyRepository = familyRepository;
_emailService = emailService;
_addressRepository = addressRepository;
_photoRepository = photoRepository;
}
/// <summary>
/// Inject repository in controller
/// </summary>
/// <param name="photoRepository">injected object</param>
/// <param name="albumRepository">injected object</param>
public PhotoController(
IPhotoRepository photoRepository,
IAlbumRepository albumRepository)
{
this.photoRepository = photoRepository;
this.albumRepository = albumRepository;
}
public AlbumService(IUsersRepository usersRepository, IAlbumRepository albumRepository, IPhotoRepository photoRepository, ITagRepository tagRepository)
{
this.mUserRepository = usersRepository;
this.mAlbumRepository = albumRepository;
this.mPhotoRepository = photoRepository;
this.mTagRepository = tagRepository;
}
public PhotoService(IPhotoRepository photoRepository, IReferenceGenerator referenceGenerator)
{
Check.If(photoRepository).IsNotNull();
Check.If(referenceGenerator).IsNotNull();
_photoRepository = photoRepository;
_referenceGenerator = referenceGenerator;
}
public override void Dispose()
{
if (_photoRepository == null) return;
_photoRepository.Dispose();
_photoRepository = null;
if (_profileRepository == null) return;
_profileRepository.Dispose();
_profileRepository = null;
}
public HomeController(
IPromotionRepository promotionRepository,
IPhotoRepository photoRepository,
IPriceListRepository priceListRepository
)
{
_promotionRepository = promotionRepository;
_photoRepository = photoRepository;
_priceListRepository = priceListRepository;
}
public OrderingController(IOrderingRepository orderings,
IOrderingHeaderContentRepository headerContent,
IInstrumentTypeRepository instrumentTypes,
IClassificationRepository classifications,
ISubClassificationRepository subClassifications,
IPhotoRepository photos)
{
_orderings = orderings;
_headerContent = headerContent;
_photos = photos;
_instrumentTypes = instrumentTypes;
_classifications = classifications;
_subClassifications = subClassifications;
}
public LikeRepository(
ISystem system,
IPhotoRepository photoRepository,
IScoreCalculator scoreCalculator,
IDynamoDbCore dynamoDbCore,
ILogWriterFactory logWriterFactory)
{
if (logWriterFactory is null)
{
throw new System.ArgumentNullException(nameof(logWriterFactory));
}
logWriter = logWriterFactory.CreateLogger <LikeRepository>();
this.system = system ?? throw new System.ArgumentNullException(nameof(system));
this.photoRepository = photoRepository ?? throw new ArgumentNullException(nameof(photoRepository));
this.scoreCalculator = scoreCalculator ?? throw new ArgumentNullException(nameof(scoreCalculator));
this.dynamoDbCore = dynamoDbCore ?? throw new System.ArgumentNullException(nameof(dynamoDbCore));
tableName = system.Environment.GetVariable(Constants.EnvironmentVariables.DynamoDbTableName);
}
public PhotosController(
IMapper mapper,
ICarRepository CarRepository,
IUnitOfWork UnitOfWork,
IWebHostEnvironment webHostingEnvironment,
IOptionsSnapshot <PhotoSettings> photoSettings,
IPhotoRepository photoRepositroy,
IPhotoService PhotoService
)
{
_mapper = mapper;
_CarRepository = CarRepository;
_UnitOfWork = UnitOfWork;
_host = webHostingEnvironment;
_photoSettings = photoSettings.Value;
_PhotoRepositroy = photoRepositroy;
_photoService = PhotoService;
}
public void SetUp()
{
// 各テストごとにデータベースファイルを削除
// TODO: 実装によってCSVファイル名が違うと思うので適宜修正を
if (System.IO.File.Exists("PhotoFrameDatabaseForTest_Photo.csv"))
{
System.IO.File.Delete("PhotoFrameDatabaseForTest_Photo.csv");
}
if (System.IO.File.Exists("PhotoFrameDatabaseForTest_Album.csv"))
{
System.IO.File.Delete("PhotoFrameDatabaseForTest_Album.csv");
}
// リポジトリ生成
var repos = new RepositoryFactory(Type.Csv);
photoRepository = repos.PhotoRepository;
albumRepository = repos.KeywordRepository;
}
public AttractionControllerTest()
{
var optionsBuilder = new DbContextOptionsBuilder <ApplicationDbContext>();
optionsBuilder.UseInMemoryDatabase();
var context = new ApplicationDbContext(optionsBuilder.Options);
var mockMapper = new MapperConfiguration(cfg =>
{
cfg.AddProfile(new AutoMapperProfiles());
});
var mapper = mockMapper.CreateMapper();
_photoRepo = new PhotoRepoFake(context);
_appUserRepo = new AppUserRepoFake(context);
_repo = new AttractionRepoFake(context);
_controller = new AttractionController(_appUserRepo, mapper, null, _repo, _photoRepo, null);
}
public PhotosController(IMapper mapper,
IPhotoRepository photoRepository, ICategoryRepository categoryRepository, IUserRepository userRepository,
ICommentRepository commentRepository, IAlbumRepository albumRepository, IUnitOfWork unitOfWork, IPhotoUploadService photoUploadService,
IWebHostEnvironment host, IObjectDetectionService objectDetectionService)
{
this.objectDetectionService = objectDetectionService;
this.host = host;
this.photoUploadService = photoUploadService;
this.unitOfWork = unitOfWork;
this.photoRepository = photoRepository;
this.categoryRepository = categoryRepository;
this.userRepository = userRepository;
this.commentRepository = commentRepository;
this.albumRepository = albumRepository;
this.mapper = mapper;
this.uploadsFolderPath = Path.Combine(host.WebRootPath, "uploads");
this.uploadsFolderUrl = "/uploads";
this.outputFolderPath = Path.Combine(host.WebRootPath, "uploads", "output");
this.outputFolderUrl = "/uploads/output";
}
private PhotoController CreateController(Session testSession, Photo testPhoto)
{
var repository = new MockRepository(MockBehavior.Default);
ISessionRepository sessionRepository = repository.Of <ISessionRepository>()
.Where(sr => sr.GetLastSessionForUser(It.IsAny <int>()) == testSession)
.First();
IPhotoRepository photoRepository = repository.Of <IPhotoRepository>()
.Where(pr => pr.GetLastPhotoInSession(It.IsAny <int>()) == testPhoto)
.First();
return(new PhotoController(new LoggerFactory(), photoRepository, sessionRepository)
{
ControllerContext = new ControllerContext()
{
HttpContext = app.HttpContext
}
});
}
public RepositoryFactory(Type t)
{
this.type = t;
switch (type)
{
case Type.Csv:
AlbumRepository = new Csv.AlbumRepository(DatabaseName);
PhotoRepository = new Csv.PhotoRepository(DatabaseName, AlbumRepository);
break;
case Type.EF:
// TODO: EFに適した生成に変更してください
AlbumRepository = new EF.AlbumRepository(/* DatabaseName */);
PhotoRepository = new EF.PhotoRepository(AlbumRepository);
break;
default:
throw new ArgumentException("The specified type is not supported.");
}
}
public BaseResponse DeletePhoto(string id)
{
try
{
IPhotoRepository photoRepository = RepositoryClassFactory.GetInstance().GetPhotoRepository();
photoRepository.Delete(id);
return(new BaseResponse
{
ErrorCode = (int)ErrorCode.None,
Message = Resources.Resource.msg_delete_success
});
}
catch (Exception ex)
{
return(new BaseResponse
{
ErrorCode = (int)ErrorCode.Error,
Message = ex.Message
});
}
}
public UnitOfWork(ApplicationDbContext applicationDataBaseContext,
UserManager <User> userManager,
SignInManager <User> signInManager,
ICommentsRepository comments,
IFilmsRepository films,
IUserRepository users,
IPhotoRepository photos,
IUserFilmsRepository userFilms,
IRatingsRepository ratings)
{
ApplicationDataBaseContext = applicationDataBaseContext;
UserManager = userManager;
SignInManager = signInManager;
UserFilms = userFilms;
Comments = comments;
Films = films;
Users = users;
Photos = photos;
Ratings = ratings;
}
/// <summary>
/// コンストラクタ
/// </summary>
public PhotoFrameForm()
{
InitializeComponent();
// リポジトリ生成・初期化
RepositoryFactory repositoryFactory = new RepositoryFactory(PhotoFrame.Persistence.Type.Csv);
//RepositoryFactory repositoryFactory = new RepositoryFactory(PhotoFrame.Persistence.Type.EF);
ServiceFactory serviceFactory = new ServiceFactory();
photoRepository = repositoryFactory.PhotoRepository;
keywordRepository = repositoryFactory.KeywordRepository;
photoFileService = serviceFactory.PhotoFileService;
searchedPhotos = new List <Photo>().AsEnumerable();
controller = new Controller(keywordRepository, photoRepository, photoFileService);
// キーワード解除用文字列の登録
comboBoxChangeKeyword.Items.Add("設定解除");
// 全アルバム名を取得し、アルバム変更リストをセット
UpdateKeywordList();
}
public RepositoryFactory(Type t)
{
this.type = t;
switch (type)
{
case Type.Csv:
KeywordRepository = new Csv.KeywordRepository(DatabaseName);
PhotoRepository = new Csv.PhotoRepository(DatabaseName, KeywordRepository);
break;
case Type.EF:
// TODO: EFに適した生成に変更してください
SqlProviderServices sqlProviderServices = SqlProviderServices.Instance;
KeywordRepository = new EF.KeywordRepository(sqlProviderServices);
PhotoRepository = new EF.PhotoRepository(KeywordRepository, sqlProviderServices);
break;
default:
throw new ArgumentException("The specified type is not supported.");
}
}
private void Initialize(bool initializeWithData)
{
if (initializeWithData)
{
var albums = new List <Repository.Contracts.DTOs.Album> {
new Repository.Contracts.DTOs.Album {
Id = 1, UserId = 1, Title = "Album1"
},
new Repository.Contracts.DTOs.Album {
Id = 2, UserId = 2, Title = "Album2"
},
new Repository.Contracts.DTOs.Album {
Id = 3, UserId = 2, Title = "Album3"
}
};
var photos = new List <Repository.Contracts.DTOs.Photo> {
new Repository.Contracts.DTOs.Photo {
Id = 1, Title = "Photo1", AlbumId = 1, Url = "a", ThumbnailUrl = "a"
},
new Repository.Contracts.DTOs.Photo {
Id = 2, Title = "Photo2", AlbumId = 2, Url = "b", ThumbnailUrl = "b"
},
new Repository.Contracts.DTOs.Photo {
Id = 3, Title = "Photo3", AlbumId = 2, Url = "b", ThumbnailUrl = "c"
},
new Repository.Contracts.DTOs.Photo {
Id = 4, Title = "Photo4", AlbumId = 3, Url = "c", ThumbnailUrl = "c"
}
};
_albumRepository = new DummyAlbumRepository(albums);
_photoRepository = new DummyPhotoRepository(photos);
}
else
{
_albumRepository = new DummyAlbumRepository();
_photoRepository = new DummyPhotoRepository();
}
}
protected override bool UpdateItem()
{
string photoId = (string)Bucket.Instance.For.Item(PhotoColumns.ID).Value;
if (string.IsNullOrEmpty(photoId))
{
throw new Exception("Must provide a valid photoId");
}
string title = (string)Bucket.Instance.For.Item(PhotoColumns.Title).Value;
string description = (string)Bucket.Instance.For.Item(PhotoColumns.Desc).Value;
if (string.IsNullOrEmpty(title))
{
throw new Exception("photo title can not be empty");
}
using (IPhotoRepository photo = repositoryFactory.CreatePhotoRepository())
{
return(photo.SetMeta(photoId, title, string.IsNullOrEmpty(description) ? " " : description));
}
}
protected override Photo GetItem()
{
// default values
PhotoSize size = Bucket.Instance.For.Item(PhotoColumns.Photosize).Value == null ? PhotoSize.Square : (PhotoSize)Bucket.Instance.For.Item(PhotoColumns.Photosize).Value;
ViewMode viewMode = Bucket.Instance.For.Item(PhotoColumns.Viewmode).Value == null ? ViewMode.Public : (ViewMode)Bucket.Instance.For.Item(PhotoColumns.Viewmode).Value;
Photo photo = null;
using (IAuthRepository authRepository = repositoryFactory.CreateAuthRepository())
{
GenerateToken(viewMode, authRepository);
if (Bucket.Instance.For.Item(PhotoColumns.ID).Value != null)
{
using (IPhotoRepository photoRepository = repositoryFactory.CreatePhotoRepository())
{
photo = photoRepository.GetPhotoDetail((string)Bucket.Instance.For.Item(PhotoColumns.ID).Value, size);
}
}
}
return(photo);
}
public BaseResponse UpdatePhoto(PhotoModel photo)
{
try
{
IPhotoRepository photoRepository = RepositoryClassFactory.GetInstance().GetPhotoRepository();
var _photo = MapperUtil.CreateMapper().Mapper.Map <PhotoModel, Photo>(photo);
photoRepository.Update(_photo);
return(new BaseResponse
{
ErrorCode = (int)ErrorCode.None,
Message = Resources.Resource.msg_update_success
});
}
catch (Exception ex)
{
return(new BaseResponse
{
ErrorCode = (int)ErrorCode.Error,
Message = ex.Message
});
}
}
public HomeController()
{
var permissionRepository = new PermissionRepository();
var churchRepository = new ChurchRepository();
_personRepository = new PersonRepository(permissionRepository, churchRepository); var birthdayRepository = new BirthdayAndAniversaryRepository();
var personRepository = new PersonRepository(permissionRepository, new ChurchRepository());
var usernamePasswordRepository = new UsernamePasswordRepository(permissionRepository);
var groupRepository = new GroupRepository();
var messageRepository = new MessageRepository();
var messageRecepientRepository = new MessageRecepientRepository();
var messageAttachmentRepository = new MessageAttachmentRepository();
var emailSender = new EmailSender(messageRepository, messageRecepientRepository, messageAttachmentRepository, personRepository);
var churchEmailTemplatesRepository = new ChurchEmailTemplatesRepository();
var emailContentRepository = new EmailContentRepository();
var emailContentService = new EmailContentService(emailContentRepository);
_emailService = new EmailService(usernamePasswordRepository, personRepository, groupRepository, emailSender, emailContentService, churchEmailTemplatesRepository, permissionRepository);
var eventRepository = new EventRepository(birthdayRepository);
_eventService = new EventService(eventRepository, _emailService, birthdayRepository);
_personGroupRepository = new PersonGroupRepository(_personRepository);
_usernamePasswordRepository = new UsernamePasswordRepository(permissionRepository);
_photoRepository = new PhotoRepository();
_photoServices = new PhotoServices();
_personService = new PersonService(
_personRepository,
new PersonGroupRepository(_personRepository),
permissionRepository,
new PersonRoleRepository(),
new PersonOptionalFieldRepository(),
new RelationshipRepository(_personRepository),
new ChurchMatcherRepository(),
new GroupRepository(),
new FamilyRepository(_photoRepository),
_emailService,
new AddressRepository(),
_photoRepository
);
}
/// <summary>
/// コンストラクタ
/// </summary>
public Form1()
{
InitializeComponent();
// 各テストごとにデータベースファイルを削除
// (35-42をコメントアウトしても動きます)
if (System.IO.File.Exists("_Photo.csv"))
{
System.IO.File.Delete("_Photo.csv");
}
if (System.IO.File.Exists("_Album.csv"))
{
System.IO.File.Delete("_Album.csv");
}
// メンバ変数初期化
RepositoryFactory repositoryFactory = new RepositoryFactory(PhotoFrame.Persistence.Type.Csv);
ServiceFactory serviceFactory = new ServiceFactory();
photoRepository = repositoryFactory.PhotoRepository;
albumRepository = repositoryFactory.AlbumRepository;
photoFileService = serviceFactory.PhotoFileService;
application = new PhotoFrameApplication(albumRepository, photoRepository, photoFileService);
searchedPhotos = new List <Photo>().AsEnumerable();
flagAsync = false;
// 全アルバム名を取得し、アルバム変更リストをセット
IEnumerable <Album> allAlbums = albumRepository.Find((IQueryable <Album> albums) => albums);
if (allAlbums != null)
{
foreach (Album album in allAlbums)
{
comboBox_ChangeAlbum.Items.Add(album.Name);
}
}
}
public DataModel.Response.FindItemReponse <DataModel.Model.PhotoModel> FindPhotoByActionURL(string actionURL)
{
try
{
IPhotoRepository photoRepository = RepositoryClassFactory.GetInstance().GetPhotoRepository();
Photo photo = photoRepository.FindByActionURL(actionURL);
var _photo = MapperUtil.CreateMapper().Mapper.Map <Photo, PhotoModel>(photo);
return(new FindItemReponse <PhotoModel>
{
Item = _photo,
ErrorCode = (int)ErrorCode.None,
Message = string.Empty
});
}
catch (Exception ex)
{
return(new FindItemReponse <PhotoModel>
{
ErrorCode = (int)ErrorCode.Error,
Message = ex.Message
});
}
}
public FindAllItemReponse <PhotoModel> GetPhoto()
{
try
{
IPhotoRepository photoRepository = RepositoryClassFactory.GetInstance().GetPhotoRepository();
IList <Photo> photo = photoRepository.FindAll();
var _photo = photo.Select(n => MapperUtil.CreateMapper().Mapper.Map <Photo, PhotoModel>(n)).ToList();
return(new FindAllItemReponse <PhotoModel>
{
Items = _photo,
ErrorCode = (int)ErrorCode.None,
Message = string.Empty
});
}
catch (Exception ex)
{
return(new FindAllItemReponse <PhotoModel>
{
ErrorCode = (int)ErrorCode.Error,
Message = ex.Message
});
}
}
public InsertResponse CreatePhoto(PhotoModel photo)
{
try
{
IPhotoRepository photoRepository = RepositoryClassFactory.GetInstance().GetPhotoRepository();
Photo _photo = MapperUtil.CreateMapper().Mapper.Map <PhotoModel, Photo>(photo);
object id = photoRepository.Insert(_photo);
return(new InsertResponse
{
InsertID = id.ToString(),
ErrorCode = (int)ErrorCode.None,
Message = Resources.Resource.msg_create_success
});
}
catch (Exception ex)
{
return(new InsertResponse
{
ErrorCode = (int)ErrorCode.Error,
Message = ex.Message
});
}
}
public ActivityService(IOrderItemRepository orderItemRepository,
IScheduleRepository scheduleRepository,
IPhotoRepository photoRepository,
IProductRetailAuditRepository productRetailAuditRepository,
IOrderRepository orderRepository,
INoteRepository noteRepository,
IFormValueRepository formValueRepository,
IMapper mapper,
IActivityRepository activityRepository,
IUserRepository userRepository,
IRequestIdentityProvider requestIdentityProvider)
{
this.mapper = mapper;
this.activityRepository = activityRepository;
this.userRepository = userRepository;
this.requestIdentityProvider = requestIdentityProvider;
this.photoRepository = photoRepository;
this.productRetailAuditRepository = productRetailAuditRepository;
this.orderRepository = orderRepository;
this.noteRepository = noteRepository;
this.formValueRepository = formValueRepository;
this.scheduleRepository = scheduleRepository;
this.orderItemRepository = orderItemRepository;
}
public FindAllItemReponse <PhotoModel> GetPhoto(int pageSize, int pageIndex)
{
try
{
IPhotoRepository photoRepository = RepositoryClassFactory.GetInstance().GetPhotoRepository();
var result = photoRepository.FindAll(pageSize, pageIndex);
var _photo = result.Item2.Select(n => MapperUtil.CreateMapper().Mapper.Map <Photo, PhotoModel>(n)).ToList();
return(new FindAllItemReponse <PhotoModel>
{
Count = result.Item1,
Items = _photo,
ErrorCode = (int)ErrorCode.None,
Message = string.Empty
});
}
catch (Exception ex)
{
return(new FindAllItemReponse <PhotoModel>
{
ErrorCode = (int)ErrorCode.Error,
Message = ex.Message
});
}
}
/// <summary>
/// Sets the Datasource to be Mock or SQL
/// </summary>
/// <param name="dataSourceEnum">The mock status.</param>
public static void SetDataSource(DataSourceEnum dataSourceEnum)
{
switch (dataSourceEnum)
{
/*
* These will all use a Table store as the backend.
* Local is used when running azure local service
* Live and Test point to azure instances
*/
case DataSourceEnum.Local:
case DataSourceEnum.ServerLive:
case DataSourceEnum.ServerTest:
DataSourceBackendTable.Instance.SetDataSourceServerMode(dataSourceEnum);
repository = PhotoRepositoryStore.Instance;
break;
case DataSourceEnum.SQL: // Same as Mock because no sql backend for this version.
case DataSourceEnum.Mock:
default:
// Default is to use the Mock
repository = PhotoRepositoryMock.Instance;
break;
}
}
// This constructor is not used by the MVC framework but is instead provided for ease
// of unit testing this type. See the comments at the end of this file for more
// information.
public AccountController(IFormsAuthentication formsAuth, IMembershipService service, IPhotoRepository repository)
{
this.FormsAuth = formsAuth ?? new FormsAuthenticationService();
this.MembershipService = service ?? new AccountMembershipService();
this.Repository = repository ?? new PhotoRepository();
}
public PhotoService(IPhotoRepository repo)
{
Checks.Argument.IsNotNull(repo, "repo");
_repo = repo;
}
public DeletePhotoBusiness(IPhotoRepository photoRepository)
{
_photoRepository = photoRepository;
}
public HomeController(IPhotoRepository repository)
{
this.repository = repository;
}
public PhotosController(IPhotoService photoService, IPhotoRepository photoRepository, IAudioRepository audioRepository)
{
_photoService = photoService;
_photoRepository = photoRepository;
_audioRepository = audioRepository;
}
public PhotosController(IPhotoRepository photoRepository)
{
_photoRepository = photoRepository;
}
//// If you are using Dependency Injection, you can delete the following constructor
//public PhotosController() : this(new PhotoRepository())
//{
//}
public PhotosController(IPhotoRepository photoRepository)
{
this.photoRepository = photoRepository;
}
public PhotoService(IPhotoRepository photoRepository, IImageUtility imageUtility, IGalleryModuleConfiguration galleryModuleConfiguration)
{
_photoRepository = photoRepository;
_imageUtility = imageUtility;
_galleryModuleConfiguration = galleryModuleConfiguration;
}
public PhotoController(IPhotoRepository photoRepo)
{
_photoRepo = photoRepo;
}
public CarsController(IMapper mapper, ICarRepository CarRepository, IUnitOfWork UnitOfWork, IPhotoRepository PhotoRepository)
{
_mapper = mapper;
_CarRepository = CarRepository;
_UnitOfWork = UnitOfWork;
_PhotoRepository = PhotoRepository;
}
public UploadController(IPhotoRepository photos)
{
_photosRepository = photos;
}
public SearchController(IPhotoRepository repository)
{
this.repository = repository;
}
public void Setup()
{
_mockDbSettings.Setup(x => x.ConnectionString).Returns("TestConectionString");
_mockContext.Setup(x => x.Properties).Returns(_mockDbSet.Object);
_mockContext.Setup(x => x.SaveChanges()).Returns(1);
_mockPhotoMapper.Setup(x => x.Map(It.IsAny<Photo>(), It.IsAny<Photo>())).Returns(true);
_photoRepository = new PhotoRepository(_mockContext.Object, _mockPhotoMapper.Object);
}
public MainProcess(IPhotoRepository photoRepository, NewTripForm newTripFrom)
{
_photoRepository = photoRepository;
_newTripFrom = newTripFrom;
}
public PhotosController(IPhotoRepository photoRepository, ILoggingRepository loggingRepository)
{
_photoRepository = photoRepository;
_loggingRepository = loggingRepository;
}
public PhotoService(IPhotoRepository photoRepository)
{
_photoRepository = photoRepository ?? new PhotoRepository();
}
public ImagesController()
{
_photoRepository = new PhotoRepository();
_photoServices = new PhotoServices();
}
//private readonly IImageResizerService _imageResizerService;
//private readonly IImageDiskService _imageDiskService;
//private readonly IValidationService _validator;
public TempImageStorageService(IPhotoRepository repo)
{
Checks.Argument.IsNotNull(repo, "repo");
_tempImageStorageRepository = repo;
}
public PhotoService(IPhotoRepository photoRepository)
{
_photoRepository = photoRepository;
}
public ImagesController(IPhotoRepository PhotoRepository, IApplicationRepository <Project> projectRepository, IHostingEnvironment hosting)
{
this.PhotoRepository = PhotoRepository;
this.projectRepository = projectRepository;
this.hosting = hosting;
}
public FamilyRepository(IPhotoRepository photoRepository)
{
_photoRepository = photoRepository;
}
public CreateAlbum(IAlbumRepository albumRepository, IPhotoRepository photoRepository)
{
this.albumRepository = albumRepository;
this.photoRepository = photoRepository;
}
public PhotoController(IPhotoRepository repository)
{
this._repository = repository;
}
public AlbumController(IPhotoRepository repository)
{
this.repository = repository;
}
public PhotoController()
{
_photoRepo = EntityPhotoRepository.Instance;
_profileRepo = EntityProfileRepository.Instance;
_feedRepo = EntityActivityRepository.Instance;
}
private IPhotoRepository _rep; // = new EfRepository();
public PhotoController(IPhotoRepository rep)
{
_rep = rep;
}
public PhotoService(IUnitOfWork uow, IPhotoRepository repository,IUserService userService)
{
this.uow = uow;
this.photoRepository = repository;
this.userService = userService;
}
public PhotosController(IHostingEnvironment host, IVehicleRepository repository, IUnitOfWork unitOfWork, IMapper mapper, IOptionsSnapshot <PhotoSettings> options, IPhotoRepository photoRepository)
{
this.photoSettings = options.Value;
this.mapper = mapper;
this.unitOfWork = unitOfWork;
this.repository = repository;
this.host = host;
this.photoRepository = photoRepository;
}
public PhotoService(IUsersRepository usersRepository, IPhotoRepository photoRepository)
{
this.mUserRepository = usersRepository;
this.mPhotoRepository = photoRepository;
}
