public PersonService(IPersonRepository personRepository, IWebHostEnvironment webHostEnvironment, IUploadRepository uploadRepository, IOptions <AppSettings> appSettings)
{
_webHostEnvironment = webHostEnvironment;
this._personRepository = personRepository;
this._uploadRepository = uploadRepository;
this._appSettings = appSettings.Value;
}
public CarouselModel(IUploadRepository uploadRepository, UserManager <ApplicationUser> userManager, IHostingEnvironment env)
{
_uploadRepository = uploadRepository;
_userManager = userManager;
_env = env;
Carousels = new List <CarouselViewModel>();
}
public UploadFileController(IUploadRepository uploadRepository, ICustomerRepository icustomerRepository, IHostingEnvironment environment, ILoggerManager logger)
{
_uploadRepository = uploadRepository;
_hostingEnvironment = environment;
_logger = logger;
_icustomerRepository = icustomerRepository;
}
public AvatarController(IPopupService popupService, IUploadAvatarService uploadAvatarService, IUploadRepository uploadRepository,
IEntityRepository entityRepository) : base(popupService)
{
this.uploadAvatarService = uploadAvatarService;
this.uploadRepository = uploadRepository;
this.entityRepository = entityRepository;
}
public IndexModel(IProductRepository productRepository, IUploadRepository uploadRepository)
{
_productRepository = productRepository;
_uploadRepository = uploadRepository;
Products = new List <ProductListViewModel>();
Carousels = new List <CarouselViewModel>();
}
public VoteService(IVoteRepository voteRepository, IUserRepository userRepository, IRateChoiceRepository rateChoiceRepository, IUploadRepository uploadRepository)
{
VoteRepository = voteRepository;
UserRepository = userRepository;
RateChoiceRepository = rateChoiceRepository;
_uploadRepository = uploadRepository;
}
internal RepositoryUploadFile(string inputFieldName, string fileName, string contentType, string tempKey, IUploadRepository repository)
{
this._contentType = contentType;
this._fileName = fileName.EqualsIgnoreCase("blob") ? inputFieldName : fileName;
this._inputFieldName = inputFieldName;
this.TempKey = tempKey;
_repository = repository;
}
/// <summary>
/// Constructors sets dependent components.
/// </summary>
/// <param name="imageAnalysisService">Image analysis service.</param>
/// <param name="storageService">Storage service.</param>
/// <param name="uploadRepository">Upload repository.</param>
/// <param name="unitOfWorkFactory">Unit of work factory.</param>
/// <param name="uploadValidator">Validates upload actions.</param>
public UploadService(IImageAnalysisService imageAnalysisService, IStorageService storageService, IUploadRepository uploadRepository, IUnitOfWorkFactory unitOfWorkFactory, IUploadValidator uploadValidator)
{
_imageAnalysisService = imageAnalysisService;
_storageService = storageService;
_uploadRepository = uploadRepository;
_unitOfWorkFactory = unitOfWorkFactory;
_uploadValidator = uploadValidator;
}
public UserRepository(IMapper mapper, IDiffenDbClient dbClient, UserManager <AppUser> userManager, IUploadRepository uploadRepository, IMemoryCache cache)
{
_mapper = mapper;
_dbClient = dbClient;
_userManager = userManager;
_uploadRepository = uploadRepository;
_cache = cache;
}
public AuthController(IUserRepository userRepository, UserManager <AppUser> userManager, SignInManager <AppUser> signInManager, IUploadRepository uploadRepository, IRegionRepository regionRepository)
{
_userRepository = userRepository;
_userManager = userManager;
_signInManager = signInManager;
_uploadRepository = uploadRepository;
_regionRepository = regionRepository;
}
public ViewModel(ICartRepository cartRepository, IUploadRepository uploadRepository)
{
_cartRepository = cartRepository;
_uploadRepository = uploadRepository;
Total = 0M;
Products = new List <ProductCartViewModel>();
Shipping = new ShippingViewModel();
}
public UploadService(IUploadRepository uploadRepository, IReferenceGenerator referenceGenerator)
{
Check.If(uploadRepository).IsNotNull();
Check.If(referenceGenerator).IsNotNull();
_uploadRepository = uploadRepository;
_referenceGenerator = referenceGenerator;
}
public UploadController(IUserAccountRepository DefineUserRepository,
IUploadRepository UploadRepository)
{
_RDefineUser = DefineUserRepository;
_RUpload = UploadRepository;
EUpload = new UploadExtentions(_RUpload, _RDefineUser);
EDefineUser = new UserAccountExtentions(_RDefineUser);
}
public HomeController(IUploadRepository uploadRepository,
IHostingEnvironment hostingEnvironment,
ILogger <HomeController> logger)
{
_uploadRepository = uploadRepository;
this.hostingEnvironment = hostingEnvironment;
this.logger = logger;
}
/// <summary>
/// BURO = Batch Update Review Outcomes
/// </summary>
/// <returns></returns>
public BuroViewModel Execute(BuroViewModel vm
, IUploadRepository uploadRepository
, IQuestionnaireRepository questionnaireRepository
, IAuditService auditService
, IReviewRepository reviewRepository)
{
var uploadList = uploadRepository.GetAll();
foreach (var upload in uploadList)
{
if (upload.AcceptedFlag)
{
continue; // once upload is accepted its over
}
var uploadId = upload.UploadId;
var reviewList = reviewRepository.GetAllByUploadId(uploadId);
foreach (var review in reviewList)
{
vm.ReviewsRead++;
IsDirty = false;
// get the questionaire data
var q = questionnaireRepository.GetReviewQuestionnaireByReviewId(review.ReviewId);
if (q == null)
{
continue;
}
var oldVals = review;
CheckForQuestionaireAssessmentOutcome(q, review);
CheckForQuestionaireRecoveryReason(q, review);
CheckForQuestionaireAssessmentAction(q, review);
CheckForQuestionaireFinalOutcome(q, review);
if (!IsDirty)
{
continue;
}
var errors = new List <IntegrityError>();
ApplyReviewModelValidations(review, errors);
if (errors.Count > 0)
{
AuditErrors(auditService, errors);
vm.ValidationErrors += errors.Count;
}
else
{
review.UpdatedBy = BuroUser;
review.UpdatedOn = DateTime.Now;
reviewRepository.Update(review);
auditService.AuditActivity(UpdateMessage(review, oldVals), BuroUser);
vm.ReviewsUpdated++;
}
}
}
return(vm);
}
public UploadService(IUploadRepository uploadRepository,
IXlsxStreamProcessor <TransactionRowModel> xlsxStreamProcessor,
IValidationTransactService validationService
)
{
this.uploadRepository = uploadRepository;
this.xlsxStreamProcessor = xlsxStreamProcessor;
this.validationService = validationService;
}
public IssueManager(IIssueRepository issueRepository, IProjectRepository iProjectRepository, IActivityRepository activityRepository, IUserAuthHelper userSessionHelper, ICache cache, IUploadRepository uploadRepository)
{
this.issueRepository = issueRepository;
this.iProjectRepository = iProjectRepository;
this.activityRepository = activityRepository;
this.userSessionHelper = userSessionHelper;
this.cache = cache;
this.uploadRepository = uploadRepository;
}
public AddModel(IHostingEnvironment env, UserManager <ApplicationUser> userManager, IProductRepository productRepository, IUploadRepository uploadRepository, IGeneralServices generalServices, ICategoryRepository categoryRepository)
{
_env = env;
_userManager = userManager;
_productRepository = productRepository;
_uploadRepository = uploadRepository;
_generalServices = generalServices;
_categoryRepository = categoryRepository;
}
public RepositoryBodyWriter(IUploadRepository repository, string clientFileName)
{
if (repository == null)
{
throw new ArgumentNullException("repository");
}
_repository = repository;
this.ClientFileName = clientFileName;
this.TempKey = _repository.Begin(IOUtil.GetExtension(clientFileName));
}
public UploadManager(IUploadRepository uploadRepository, IRequestRepository requestRepository, IFileOperationsManager fileOperationsManager, IBlobHelper blobHelper, ICourseManager courseManager, IUserManager userManager, IRequestManager requestManager)
{
_uploadRepository = uploadRepository;
_courseManager = courseManager;
_requestManager = requestManager;
_userManager = userManager;
_fileOperationsManager = fileOperationsManager;
_blobHelper = blobHelper;
_requestRepository = requestRepository;
}
public UploadTesting()
{
IConfigurationBuilder configuration = new ConfigurationBuilder();
configuration.AddJsonFile("appsettings.json");
_configuration = configuration.Build();
_uploadRepository = new UploadRepository(_configuration);
_uploadBusiness = new UploadBusiness(_uploadRepository);
controller = new UploadController(_uploadBusiness, _configuration);
}
public IndexModel(ICartRepository cartRepository, UserManager <ApplicationUser> userManager, SignInManager <ApplicationUser> signInManager, IUploadRepository uploadRepository, IProductRepository productRepository)
{
_cartRepository = cartRepository;
_userManager = userManager;
_signInManager = signInManager;
_uploadRepository = uploadRepository;
_productRepository = productRepository;
Products = new List <ProductCartViewModel>();
Total = 0M;
}
public IssueManager(IIssueRepository issueRepository, IProjectRepository iProjectRepository,
IActivityRepository activityRepository, IUserAuthHelper userSessionHelper, ICache cache,IUploadRepository uploadRepository,IEmailManager emailManager)
{
this.issueRepository = issueRepository;
this.iProjectRepository = iProjectRepository;
this.activityRepository = activityRepository;
this.userSessionHelper = userSessionHelper;
this.cache = cache;
this.uploadRepository = uploadRepository;
this.emailManager = emailManager;
}
public IndexModel(IProductRepository productRepository, IUploadRepository uploadRepository, ICategoryRepository categoryRepository, SignInManager <ApplicationUser> signInManager, ICartRepository cartRepository, UserManager <ApplicationUser> userManager, IHostingEnvironment env)
{
_productRepository = productRepository;
_uploadRepository = uploadRepository;
_categoryRepository = categoryRepository;
_cartRepository = cartRepository;
_signInManager = signInManager;
_userManager = userManager;
_env = env;
Uploads = new List <UploadViewModel>();
Products = new List <ProductListViewModel>();
}
/// <summary>
///
/// </summary>
public UploadController(
IUploadRepository uploadRepository,
ITokenRepository tokenRepository,
IBuildingRepository buildingRepository,
IBuildingUnitRepository buildingUnitRepository,
IIndustryRepository industryRepository,
IOwnerRepository ownerRepository)
{
_uploadRepository = uploadRepository;
_tokenRepository = tokenRepository;
_buildingRepository = buildingRepository;
_buildingUnitRepository = buildingUnitRepository;
_industryRepository = industryRepository;
_ownerRepository = ownerRepository;
}
/// <summary>
/// Initializes a new instance of the <see cref="UploadService"/> class.
/// </summary>
/// <param name="loggerFactory">Logger factory for this service</param>
/// <param name="configuration">Application configuration</param>
public UploadService(ILoggerFactory loggerFactory, IConfiguration configuration)
: base(loggerFactory, configuration)
{
this.Logger.LogTrace("Construction of Upload Service beginning");
// Build cosmos configuration
var azureBlobConfiguration = AzureBlobConfiguration.BuildFromConfiguration(this.Configuration);
var profilePictureContainerName = this.Configuration["AzureBlob:ProfilePhotosContainer"];
Ensure.IsNotNullOrWhitespace(() => profilePictureContainerName);
this.uploadRepository = new AzureBlobUploadRepository(azureBlobConfiguration, profilePictureContainerName, loggerFactory);
this.Logger.LogTrace("Construction of Upload Service complete");
}
public DataModel.Response.BaseResponse DeleteUpload(string id)
{
try
{
IUploadRepository uploadRepository = RepositoryClassFactory.GetInstance().GetUploadRepository();
uploadRepository.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 DataModel.Response.BaseResponse UpdateUpload(DataModel.Model.UploadModel upload)
{
try
{
IUploadRepository uploadRepository = RepositoryClassFactory.GetInstance().GetUploadRepository();
Upload _upload = MapperUtil.CreateMapper().Mapper.Map <UploadModel, Upload>(upload);
uploadRepository.Update(_upload);
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 DataModel.Response.InsertResponse CreateUpload(DataModel.Model.UploadModel upload)
{
try
{
IUploadRepository uploadRepository = RepositoryClassFactory.GetInstance().GetUploadRepository();
Upload _upload = MapperUtil.CreateMapper().Mapper.Map <UploadModel, Upload>(upload);
object id = uploadRepository.Insert(_upload);
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 DataModel.Response.FindItemReponse <DataModel.Model.UploadModel> GetUploadByID(string id)
{
try
{
IUploadRepository uploadRepository = RepositoryClassFactory.GetInstance().GetUploadRepository();
Upload upload = uploadRepository.FindByID(id);
var _upload = MapperUtil.CreateMapper().Mapper.Map <Upload, UploadModel>(upload);
return(new FindItemReponse <UploadModel>
{
Item = _upload,
ErrorCode = (int)ErrorCode.None,
Message = string.Empty
});
}
catch (Exception ex)
{
return(new FindItemReponse <UploadModel>
{
ErrorCode = (int)ErrorCode.Error,
Message = ex.Message
});
}
}
public DataModel.Response.FindAllItemReponse <DataModel.Model.UploadModel> GetUploads()
{
try
{
IUploadRepository uploadRepository = RepositoryClassFactory.GetInstance().GetUploadRepository();
IList <Upload> uploads = uploadRepository.FindAll();
var _uploads = uploads.Select(a => MapperUtil.CreateMapper().Mapper.Map <Upload, UploadModel>(a)).ToList();
return(new FindAllItemReponse <UploadModel>
{
Items = _uploads,
ErrorCode = (int)ErrorCode.None,
Message = string.Empty
});
}
catch (Exception ex)
{
return(new FindAllItemReponse <UploadModel>
{
ErrorCode = (int)ErrorCode.Error,
Message = ex.Message
});
}
}
public UploadManager(IUploadRepository uploadRepository)
{
_uploadRepository = uploadRepository;
}
public ProductsController(IUploadRepository uploadRepository, IHostingEnvironment env)
{
_uploadRepository = uploadRepository;
_env = env;
}
public UploadManager(IUploadRepository uploadRepository)
{
this.uploadRepository = uploadRepository;
}