public DataServices(IFileServices services, IVirtualBlobRepository virtualBlobRepository)
{
cloudBlobContainerServices = services;
//ContainerName = containerName;
//SetUpContainer();
this.virtualBlobRepository = virtualBlobRepository;
}
public void SetUp()
{
var unitOfWork = new UnitOfWork();
// AUTH
_authUserServices = new UserServices(unitOfWork);
_roleServices = new RoleServices(unitOfWork);
_applicationServices = new ApplicationServices(unitOfWork);
_industryServices = new IndustryServices(unitOfWork);
_regionServices = new RegionServices(unitOfWork);
_countryServices = new CountryServices(unitOfWork);
_editionServices = new EditionServices(unitOfWork);
_editionCohostServices = new EditionCohostServices(unitOfWork);
_editionCountryServices = new EditionCountryServices(unitOfWork);
_editionKeyVisitorServices = new EditionKeyVisitorServices(unitOfWork);
_editionTranslationServices = new EditionTranslationServices(unitOfWork);
_editionTranslationSocialMediaServices = new EditionTranslationSocialMediaServices(unitOfWork);
_editionVisitorServices = new EditionVisitorServices(unitOfWork);
_eventServices = new EventServices(unitOfWork);
_eventDirectorServices = new EventDirectorServices(unitOfWork);
_fileServices = new FileServices(unitOfWork);
_keyVisitorServices = new KeyVisitorServices(unitOfWork);
_logServices = new LogServices(unitOfWork);
_notificationServices = new NotificationServices(unitOfWork);
_subscriptionServices = new SubscriptionServices(unitOfWork);
_userServices = new UserServices(unitOfWork);
_userRoleServices = new UserRoleServices(unitOfWork);
_editionHelper = new EditionHelper();
_controller = new EditionController(
_authUserServices,
_roleServices,
_applicationServices,
_industryServices,
_regionServices,
_countryServices,
_editionServices,
_editionCohostServices,
_editionCountryServices,
_editionKeyVisitorServices,
_editionTranslationServices,
_editionTranslationSocialMediaServices,
_editionVisitorServices,
_eventServices,
_eventDirectorServices,
_fileServices,
_keyVisitorServices,
_logServices,
_notificationServices,
_subscriptionServices,
_userServices,
_userRoleServices,
_editionHelper
);
_controller.SetDefaultUser();
AutoMapperConfig.Register();
}
private void finalizecodeActivity_ExecuteCode(object sender, EventArgs e)
{
AddNewTreeRefresher addNewTreeRefresher = this.CreateAddNewTreeRefresher(this.EntityToken);
IXsltFunction xslt = this.GetBinding <IXsltFunction>("NewXslt");
Guid copyFromFunctionId = this.GetBinding <Guid>(Binding_CopyFromFunctionId);
IXsltFunction copyFromFunction = null;
if (copyFromFunctionId != Guid.Empty)
{
copyFromFunction = DataFacade.GetData <IXsltFunction>().First(f => f.Id == copyFromFunctionId);
}
xslt.XslFilePath = xslt.CreateXslFilePath();
IFile file = IFileServices.TryGetFile <IXsltFile>(xslt.XslFilePath);
using (TransactionScope transactionScope = TransactionsFacade.CreateNewScope())
{
if (file == null)
{
IXsltFile xsltfile = DataFacade.BuildNew <IXsltFile>();
xsltfile.FolderPath = System.IO.Path.GetDirectoryName(xslt.XslFilePath);
xsltfile.FileName = System.IO.Path.GetFileName(xslt.XslFilePath);
string xslTemplate = _newXsltMarkup;
if (copyFromFunction != null)
{
IFile copyFromFile = IFileServices.GetFile <IXsltFile>(copyFromFunction.XslFilePath);
xslTemplate = copyFromFile.ReadAllText();
}
xsltfile.SetNewContent(xslTemplate);
DataFacade.AddNew <IXsltFile>(xsltfile, "XslFileProvider");
}
xslt = DataFacade.AddNew <IXsltFunction>(xslt);
UserSettings.LastSpecifiedNamespace = xslt.Namespace;
if (copyFromFunction != null)
{
CloneFunctionParameters(copyFromFunction, xslt);
CloneFunctionCalls(copyFromFunction, xslt);
}
transactionScope.Complete();
}
addNewTreeRefresher.PostRefreshMesseges(xslt.GetDataEntityToken());
FlowControllerServicesContainer container = WorkflowFacade.GetFlowControllerServicesContainer(WorkflowEnvironment.WorkflowInstanceId);
var executionService = container.GetService <IActionExecutionService>();
executionService.Execute(xslt.GetDataEntityToken(), new WorkflowActionToken(typeof(EditXsltFunctionWorkflow)), null);
}
/// <summary>
///
/// </summary>
/// <param name="fileServices"></param>
/// <param name="googleAuthService"></param>
/// <param name="usersService"></param>
/// <param name="currentUserService"></param>
/// <param name="userActionServices"></param>
public FileController(IFileServices fileServices, IGoogleAuthService googleAuthService, IUsersService usersService, ICurrentUserService currentUserService, IUserActionServices userActionServices)
{
this.fileServices = fileServices;
this.googleAuthService = googleAuthService;
this.usersService = usersService;
this.currentUserService = currentUserService;
this.userActionServices = userActionServices;
}
public FileController(IFileServices fileServices,
IFileModelFactory fileModelFactory,
IMemoryCache memoryCache)
{
_fileServices = fileServices;
_fileModelFactory = fileModelFactory;
_memoryCache = memoryCache;
}
public RealEstateController(IRealEstateServices realEstateServices,
IFileServices fileServices,
ICommonServices commonServices)
{
_realEstateServices = realEstateServices;
_fileServices = fileServices;
_commonServices = commonServices;
}
public FileController(IFileServices fileServices, IWebHostEnvironment hostEnvironment, UserManager <ApplicationUser> userManager, ILogger <FileController> logger)
{
//_db = db;
this._hostEnvironment = hostEnvironment;
_userManager = userManager;
_logger = logger;
_fileServices = fileServices;
}
/// <summary>
/// Initialize of controller
/// </summary>
/// <param name="medicalSpecialistService">Medical Specialist services <see cref="IMedicalSpecialistService"/></param>
/// <param name="fileService">File services <see cref="IFileServices"/></param>
public SpecialistController(IMedicalSpecialistService medicalSpecialistService,
IFileServices fileService)
{
_medicalSpecialistService = medicalSpecialistService;
_fileService = fileService;
//init
_medicalSpecialistService.Initialize(new ModelStateWrapper(this.ModelState));
}
public AuthorsController(IAuthorServices services,
IBookServices bookServices,
IFileServices fileServices,
IParameterBuilder parameterBuilder)
{
_services = services;
_bookServices = bookServices;
_fileServices = fileServices;
_parameterBuilder = parameterBuilder;
}
/// <summary>
/// Initializes a new instance of the <see cref="T:MediCore.Api.Controllers.AccountController"/> class.
/// </summary>
/// <param name="userService">User Service</param>
/// <param name="authServices">Auth services.</param>
/// <param name="userDetailService">User detail service.</param>
/// <param name="patientService">File service.</param>
/// <param name="fileServices">Patient service.</param>
/// <param name="sender">Sender.</param>
/// <param name="hostingEnvironment">Hosting environment.</param>
public AccountController(IUserService userService, IAuthenticationService authServices, IUserDetailService userDetailService, IPatientService patientService, IFileServices fileServices, ISenderFactory sender, IHostingEnvironment hostingEnvironment)
{
_userService = userService;
_authServices = authServices;
_userDetailService = userDetailService;
_patientService = patientService;
_sender = sender;
_fileServices = fileServices;
_hostingEnvironment = hostingEnvironment;
}
private void initializeCodeActivity_ExecuteCode(object sender, EventArgs e)
{
DataEntityToken dataEntityToken = (DataEntityToken)this.EntityToken;
this.Bindings.Add("PageTemplate", dataEntityToken.Data);
this.Bindings.Add("OldTitle", ((IXmlPageTemplate)dataEntityToken.Data).Title);
string templatePath = ((IXmlPageTemplate)dataEntityToken.Data).PageTemplateFilePath;
IPageTemplateFile file = IFileServices.TryGetFile <IPageTemplateFile>(templatePath);
this.Bindings.Add("PageTemplateMarkup", file.ReadAllText());
}
public BooksController(IBookServices services,
IAuthorServices authorServices,
IGenreServices genreServices,
IParameterBuilder parameterBuilder,
IFileServices fileServices)
{
_services = services;
_authorServices = authorServices;
_genreServices = genreServices;
_fileServices = fileServices;
_parameterBuilder = parameterBuilder;
}
public EmailService(IAWSEmailService awsEmailService,
IFileServices fileServices,
IViewRenderService viewRenderService,
IOptions <CommonSettings> bulkUserSettings,
ILogger <EmailService> logger)
{
_awsEmailService = awsEmailService;
_fileServices = fileServices;
_viewRenderService = viewRenderService;
_commonSettings = bulkUserSettings.Value;
_logger = logger;
}
/// <summary>
///
/// </summary>
/// <param name="env"></param>
/// <param name="verifyService"></param>
/// <param name="vacationCheckServices"></param>
/// <param name="context"></param>
/// <param name="applyService"></param>
/// <param name="currentUserService"></param>
/// <param name="usersService"></param>
/// <param name="companiesService"></param>
/// <param name="httpContext"></param>
/// <param name="fileServices"></param>
public StaticController(IWebHostEnvironment env, IVerifyService verifyService, IVacationCheckServices vacationCheckServices, ApplicationDbContext context, IApplyVacationService applyService, ICurrentUserService currentUserService, IUsersService usersService, ICompaniesService companiesService, IHttpContextAccessor httpContext, IFileServices fileServices)
{
this.env = env;
_verifyService = verifyService;
_vacationCheckServices = vacationCheckServices;
_context = context;
_applyService = applyService;
_currentUserService = currentUserService;
_usersService = usersService;
_companiesService = companiesService;
_httpContext = httpContext;
_fileServices = fileServices;
}
internal PageTemplateFileWrapper(IXmlPageTemplate pageTemplate)
{
_pageTemplateFilePath = pageTemplate.PageTemplateFilePath;
IFile file = IFileServices.GetFile <IPageTemplateFile>(_pageTemplateFilePath);
_content = file.ReadAllText();
var systemFile = file as FileSystemFileBase;
Verify.IsNotNull(systemFile, "File should be of type '{0}'", typeof(FileSystemFileBase).Name);
_fileFullPath = systemFile.SystemPath;
file.SubscribeOnChanged(OnFileChanged);
}
public EditionCohostController(
IUserServices authUserServices,
IRoleServices roleServices,
IApplicationServices applicationServices,
IIndustryServices industryServices,
IRegionServices regionServices,
IEditionServices editionServices,
IEditionCohostServices editionCohostServices,
IEventServices eventServices,
IEventDirectorServices eventDirectorServices,
IFileServices fileServices,
ILogServices logServices,
INotificationServices notificationServices,
IUserServices userServices,
IUserRoleServices userRoleServices) :
base(authUserServices, roleServices, applicationServices, industryServices, regionServices,
editionServices, editionCohostServices, eventServices, eventDirectorServices, fileServices, logServices,
notificationServices, userServices, userRoleServices)
{
}
private void codeActivity1_ExecuteCode(object sender, EventArgs e)
{
DataEntityToken dataEntityToken = (DataEntityToken)this.EntityToken;
IXsltFunction xsltFunction = (IXsltFunction)dataEntityToken.Data;
if (DataFacade.WillDeleteSucceed <IXsltFunction>(xsltFunction))
{
DeleteTreeRefresher deleteTreeRefresher = this.CreateDeleteTreeRefresher(this.EntityToken);
IFile file = IFileServices.TryGetFile <IXsltFile>(xsltFunction.XslFilePath);
DataFacade.Delete <IParameter>(f => f.OwnerId == xsltFunction.Id);
DataFacade.Delete <INamedFunctionCall>(f => f.XsltFunctionId == xsltFunction.Id);
DataFacade.Delete(xsltFunction);
DeleteFile(file);
int count =
(from info in DataFacade.GetData <IXsltFunction>()
where info.Namespace == xsltFunction.Namespace
select info).Count();
if (count == 0)
{
RefreshFunctionTree();
}
else
{
deleteTreeRefresher.PostRefreshMesseges();
}
}
else
{
this.ShowMessage(
DialogType.Error,
StringResourceSystemFacade.GetString("Composite.Plugins.XsltBasedFunction", "DeleteXsltFunctionWorkflow.CascadeDeleteErrorTitle"),
StringResourceSystemFacade.GetString("Composite.Plugins.XsltBasedFunction", "DeleteXsltFunctionWorkflow.CascadeDeleteErrorMessage")
);
}
}
public void DeleteTemplate()
{
IFile file = IFileServices.GetFile <IPageTemplateFile>(_pageTemplate.PageTemplateFilePath);
ProcessControllerFacade.FullDelete(_pageTemplate);
if (file != null && file is FileSystemFileBase)
{
FileSystemFileBase baseFile = file as FileSystemFileBase;
C1File.Delete(baseFile.SystemPath);
try
{
C1File.Delete(baseFile.SystemPath);
}
catch
{
LoggingService.LogWarning(LogTitle, "Failed to delete page template file: '{0}'".FormatWith(baseFile.SystemPath));
}
}
}
public GlobalController(
IUserServices authUserServices,
IRoleServices roleServices,
IApplicationServices applicationServices,
IIndustryServices industryServices,
IRegionServices regionServices,
IEditionServices editionServices,
IEditionCohostServices editionCoHostServices,
IEventServices eventServices,
IEventDirectorServices eventDirectorServices,
IFileServices fileServices,
ILogServices logServices,
INotificationServices notificationServices,
IUserServices userServices,
IUserRoleServices userRoleServices) :
this(authUserServices, roleServices, applicationServices, industryServices, regionServices,
eventServices, eventDirectorServices, logServices, notificationServices, userServices, userRoleServices)
{
EditionServices = editionServices;
EditionCoHostServices = editionCoHostServices;
FileServices = fileServices;
}
public override void OnActionExecuting(ActionExecutingContext context)
{
try
{
var id = new Guid(Encryption.SymmetricDecrypt(HttpUtility.UrlDecode(context.ActionArguments["id"].ToString())));
string currentUserId = context.HttpContext.User.Identity.Name;
IFileServices fileServices = (IFileServices)context.HttpContext.RequestServices.GetService(typeof(IFileServices));
//var allFiles = fileServices.GetAllFiles();
//var fileIndex = allFiles.Where(f => f.Id == id);
var upload = fileServices.GetFile(id);
if (upload.UserEmail.ToString() != currentUserId && !context.HttpContext.User.IsInRole("Teacher"))
{
context.Result = new UnauthorizedObjectResult("Access Denied");
}
}
catch (Exception e)
{
context.Result = new BadRequestObjectResult("BadRequest");
}
}
public GlobalController(
IUserServices authUserServices,
IRoleServices roleServices,
IApplicationServices applicationServices,
IIndustryServices industryServices,
IRegionServices regionServices,
ICountryServices countryServices,
IEditionServices editionServices,
IEditionCohostServices editionCoHostServices,
IEditionCountryServices editionCountryServices,
IEditionKeyVisitorServices editionKeyVisitorServices,
IEditionTranslationServices editionTranslationServices,
IEditionTranslationSocialMediaServices editionTranslationSocialMediaServices,
IEditionVisitorServices editionVisitorServices,
IEventServices eventServices,
IEventDirectorServices eventDirectorServices,
IFileServices fileServices,
IKeyVisitorServices keyVisitorServices,
ILogServices logServices,
INotificationServices notificationServices,
ISubscriptionServices subscriptionServices,
IUserServices userServices,
IUserRoleServices userRoleServices) :
this(authUserServices, roleServices, applicationServices, industryServices, regionServices,
eventServices, eventDirectorServices, logServices, notificationServices, userServices, userRoleServices)
{
EditionServices = editionServices;
EditionCoHostServices = editionCoHostServices;
EditionCountryServices = editionCountryServices;
EditionKeyVisitorServices = editionKeyVisitorServices;
EditionTranslationServices = editionTranslationServices;
EditionTranslationSocialMediaServices = editionTranslationSocialMediaServices;
EditionVisitorServices = editionVisitorServices;
FileServices = fileServices;
KeyVisitorServices = keyVisitorServices;
SubscriptionServices = subscriptionServices;
}
/// <summary>
/// 快捷上传文件
/// </summary>
/// <param name="file"></param>
/// <param name="fileServices"></param>
/// <param name="path"></param>
/// <param name="fileName"></param>
/// <param name="removeTime"></param>
/// <returns></returns>
public static async Task <FileReturnViewModel> UploadToDb(this FormFile file, IFileServices fileServices, string path, string fileName, TimeSpan?removeTime = null)
{
var tmpFile = await fileServices.Upload(file, path, fileName, Guid.Empty, Guid.Empty).ConfigureAwait(true);
removeTime ??= TimeSpan.FromDays(7);
return(new FileReturnViewModel()
{
Data = new FileReturnDataModel()
{
FileName = fileName,
RequestUrl = tmpFile.DownloadUrl(FileExtensions.DownloadType.ByPath),
ValidStamp = DateTime.Now.Add(removeTime.Value),
Length = tmpFile.Length
}
});
}
public FileController(IFileServices fileServices)
{
_fileServices = fileServices;
}
public TrustController()
{
services = new Services.HelperServices();
fileServices = new Services.FileServices();
utilityServices = new Services.UtiltiyServices();
}
public RegistrationController(ILogger <RegistrationController> logger, IFileServices fileService)
{
_fileService = fileService;
_logger = logger;
}
public SortName(IFileServices iFileServices, IValidateFile iValidateFile, ILoggerFactory iLoggerFactory)
{
this._IfileServices = iFileServices;
this._IValidateFile = iValidateFile;
_ILoggerFactory = iLoggerFactory.CreateLogger <SortName>();
}
private void initializeCodeActivity_ExecuteCode(object sender, EventArgs e)
{
DataEntityToken dataEntityToken = (DataEntityToken)this.EntityToken;
IXsltFunction xsltFunction = (IXsltFunction)dataEntityToken.Data;
IFile file = IFileServices.GetFile <IXsltFile>(xsltFunction.XslFilePath);
IEnumerable <ManagedParameterDefinition> parameters = ManagedParameterManager.Load(xsltFunction.Id);
this.Bindings.Add("CurrentXslt", dataEntityToken.Data);
this.Bindings.Add("Parameters", parameters);
// popular type widgets
List <Type> popularTypes = DataFacade.GetAllInterfaces(UserType.Developer);
var popularWidgetTypes = FunctionFacade.WidgetFunctionSupportedTypes.Where(f => f.GetGenericArguments().Any(g => popularTypes.Any(h => h.IsAssignableFrom(g))));
IEnumerable <Type> parameterTypeOptions = FunctionFacade.FunctionSupportedTypes.Union(popularWidgetTypes).Union(FunctionFacade.WidgetFunctionSupportedTypes);
// At the moment we don't have functions that return IEnumerable<XNode>, so we're hardcoding this type for now
parameterTypeOptions = parameterTypeOptions.Union(new [] { typeof(IEnumerable <XNode>) });
this.Bindings.Add("ParameterTypeOptions", parameterTypeOptions.ToList());
string xsltDocumentString = file.ReadAllText();
this.Bindings.Add("XslTemplate", xsltDocumentString);
this.Bindings.Add("XslTemplateLastSaveHash", xsltDocumentString.GetHashCode());
List <string> functionErrors;
List <NamedFunctionCall> FunctionCalls = RenderHelper.GetValidFunctionCalls(xsltFunction.Id, out functionErrors).ToList();
if ((functionErrors != null) && (functionErrors.Any()))
{
foreach (string error in functionErrors)
{
this.ShowMessage(DialogType.Error, "A function call has been dropped", error);
}
}
this.Bindings.Add("FunctionCalls", FunctionCalls);
this.Bindings.Add("PageId", PageManager.GetChildrenIDs(Guid.Empty).FirstOrDefault());
if (UserSettings.ActiveLocaleCultureInfo != null)
{
List <KeyValuePair <string, string> > activeCulturesDictionary = UserSettings.ActiveLocaleCultureInfos.Select(f => new KeyValuePair <string, string>(f.Name, DataLocalizationFacade.GetCultureTitle(f))).ToList();
this.Bindings.Add("ActiveCultureName", UserSettings.ActiveLocaleCultureInfo.Name);
this.Bindings.Add("ActiveCulturesList", activeCulturesDictionary);
}
this.Bindings.Add("PageDataScopeName", DataScopeIdentifier.AdministratedName);
this.Bindings.Add("PageDataScopeList", new Dictionary <string, string>
{
{ DataScopeIdentifier.AdministratedName, GetString("EditXsltFunction.LabelAdminitrativeScope") },
{ DataScopeIdentifier.PublicName, GetString("EditXsltFunction.LabelPublicScope") }
});
// Creating a session state object
Guid stateId = Guid.NewGuid();
var state = new FunctionCallDesignerState {
WorkflowId = WorkflowInstanceId, ConsoleIdInternal = GetCurrentConsoleId()
};
SessionStateManager.DefaultProvider.AddState <IFunctionCallEditorState>(stateId, state, DateTime.Now.AddDays(7.0));
this.Bindings.Add("SessionStateProvider", SessionStateManager.DefaultProviderName);
this.Bindings.Add("SessionStateId", stateId);
}
/// <summary>
/// File manipulation
/// </summary>
/// <param name="fileServices"></param>
/// <param name="imageServices"></param>
public FileController(IFileServices fileServices, IImageService imageServices)
{
_fileServices = fileServices;
_imageServices = imageServices;
}
public AuthorizationController(ILogger <AuthorizationController> logger, IFileServices fileService)
{
_fileService = fileService;
_logger = logger;
}
public OutletsController(IFileServices fileServices, IMapper mapper, IOutletService outletService)
{
_outletService = outletService;
_fileServices = fileServices;
_mapper = mapper;
}
