public AuthenticationService(ITenantRepository tenantRepository, IUserRepository userRepository,
IEncryptionService encryptionService)
{
this._tenantRepository = tenantRepository;
this._userRepository = userRepository;
this._encryptionService = encryptionService;
}
public UserManager(IUserRepository userRepository, ILandlordRepository landlordRepository, ITenantRepository tenantRepository, IPasswordHasher passwordHasher)
{
_userRepository = userRepository;
_passwordHasher = passwordHasher;
_landlordRepository = landlordRepository;
_tenantRepository = tenantRepository;
}
public TenantProvisioningService(ITenantRepository tenantRepository, IUserRepository userRepository,
IRoleRepository roleRepository)
{
this._tenantRepository = tenantRepository;
this._userRepository = userRepository;
this._roleRepository = roleRepository;
}
public AccessApplicationService(ITenantRepository tenantRepository, IGroupRepository groupRepository,
IUserRepository userRepository, IRoleRepository roleRepository)
{
this._groupRepository = groupRepository;
this._roleRepository = roleRepository;
this._tenantRepository = tenantRepository;
this._userRepository = userRepository;
}
public TenantController(ILandlordRepository ll, IApartmentRepository a,
ILocationRepository lo, ITenantRepository t, IContext con)
{
TRepo = t;
AptRepo = a;
LocRepo = lo;
LLRepo = ll;
context = con;
}
public LocationController(ILandlordRepository ll, IApartmentRepository a,
ILocationRepository lo, ITenantRepository t, IContext con, IImageRepository img)
{
TRepo = t;
AptRepo = a;
LocRepo = lo;
LLRepo = ll;
context = con;
imageRepo = img;
}
public IdentityApplicationService(AuthenticationService authenticationService,
GroupMemberService groupMemberService, TenantProvisioningService tenantProvisioningService,
ITenantRepository tenantRepository, IGroupRepository groupRepository, IUserRepository userRepository)
{
this._authenticationService = authenticationService;
this._groupMemberService = groupMemberService;
this._groupRepository = groupRepository;
this._tenantProvisioningService = tenantProvisioningService;
this._tenantRepository = tenantRepository;
this._userRepository = userRepository;
}
public ProducerHub(ILogger <ProducerHub> logger,
IProducerHubRepository producerHubRepository,
ITenantRepository tenantRepository,
ITenantFactory tenantFactory,
IProducerFactory producerFactory,
IStorageHubService storageHubService,
IConsumerHubService consumerHubService)
{
this.logger = logger;
this.producerHubRepository = producerHubRepository;
this.tenantRepository = tenantRepository;
this.tenantFactory = tenantFactory;
this.producerFactory = producerFactory;
this.storageHubService = storageHubService;
this.consumerHubService = consumerHubService;
}
public ConsumerHubService(ILogger <ConsumerHubService> logger,
IHubContext <ConsumerHub, IConsumerHub> hub,
IConsumerHubRepository consumerHubRepository,
IStorageHubService storageHubService,
ITenantRepository tenantRepository,
ITenantService tenantApiService,
IComponentService componentApiService)
{
_logger = logger;
_hub = hub;
_consumerHubRepository = consumerHubRepository;
_storageHubService = storageHubService;
_tenantRepository = tenantRepository;
_tenantApiService = tenantApiService;
_componentApiService = componentApiService;
}
/// <summary>
/// コンストラクタ
/// </summary>
public LoginLogic(
ITenantRepository tenantRepository,
IUserRepository userRepository,
ISettingRepository settingRepository,
IUnitOfWork unitOfWork,
ICommonDiLogic commonDiLogic,
IOptions <ActiveDirectoryOptions> adOptions,
IOptions <WebSecurityOptions> webSecurityOptions) : base(commonDiLogic)
{
this.tenantRepository = tenantRepository;
this.userRepository = userRepository;
this.settingRepository = settingRepository;
this.unitOfWork = unitOfWork;
this.adOptions = adOptions.Value;
this.webSecurityOptions = webSecurityOptions.Value;
}
public UserController(
UserManager <ApplicationUser> userManager,
IOptions <JwtIssuerOptions> jwtOptions,
IJwtFactory jwtFactory,
IRequestContext requestContext,
ITenantRepository tenantRepository,
IUserService userService,
IConfiguration configuration) : base(requestContext)
{
_userManager = userManager;
_jwtFactory = jwtFactory;
_jwtOptions = jwtOptions.Value;
_tenantRepository = tenantRepository;
_userService = userService;
_configuration = configuration;
}
protected void SetUp()
{
ContainerBuilder builder = new ContainerBuilder();
builder.RegisterType<MD5EncryptionService>().As<IEncryptionService>();
IContainer container = builder.Build();
ServiceLocator.Resolver = new AutofacResolver(container);
_sessionProvider = new SessionProvider("server=.;uid=sa;pwd=truth;Trusted_Connection=no;database=IDDD", typeof(GroupRepository).Assembly);
this.UserRepository = new UserRepository(_sessionProvider);
this.GroupRepository = new GroupRepository(_sessionProvider);
this.TenantRepository = new TenantRepository(_sessionProvider);
this.RoleRepository = new RoleRepository(_sessionProvider);
_transaction = Session.BeginTransaction();
DomainEventPublisher.Instance.Reset();
}
public TenantResolver(HostContext context, IHttpContextAccessor accessor, IAliasRepository aliasrepository, ITenantRepository tenantrepository)
{
db = context;
_aliasrepository = aliasrepository;
_tenantrepository = tenantrepository;
// get alias based on request context
aliasname = accessor.HttpContext.Request.Host.Value;
string path = accessor.HttpContext.Request.Path.Value;
string[] segments = path.Split('/');
if (segments[1] != "~")
{
aliasname += "/" + segments[1];
}
}
public PatchTenantCommand(
IActionContextAccessor actionContextAccessor,
IObjectModelValidator objectModelValidator,
ITenantRepository tenantRepository,
IMapper <Data.Tenant, ViewModels.Tenant> tenantToTenantMapper,
IMapper <Data.Tenant, SaveTenant> tenantToSaveTenantMapper,
IMapper <SaveTenant, Data.Tenant> saveTenantToTenantMapper,
IHostTenantInfo host)
{
this.actionContextAccessor = actionContextAccessor ?? throw new ArgumentNullException(nameof(actionContextAccessor));
this.objectModelValidator = objectModelValidator ?? throw new ArgumentNullException(nameof(objectModelValidator));
this.tenantRepository = tenantRepository ?? throw new ArgumentNullException(nameof(tenantRepository));
this.tenantToTenantMapper = tenantToTenantMapper ?? throw new ArgumentNullException(nameof(tenantToTenantMapper));
this.tenantToSaveTenantMapper = tenantToSaveTenantMapper ?? throw new ArgumentNullException(nameof(tenantToSaveTenantMapper));
this.saveTenantToTenantMapper = saveTenantToTenantMapper ?? throw new ArgumentNullException(nameof(saveTenantToTenantMapper));
this.host = host ?? throw new ArgumentNullException(nameof(host));
}
public LoginController(TelemetryScopedLogger logger, IStringLocalizer localizer, ITenantRepository tenantRepository, LoginPageLogic loginPageLogic, SessionLoginUpPartyLogic sessionLogic, SequenceLogic sequenceLogic, SecurityHeaderLogic securityHeaderLogic, AccountLogic userAccountLogic, AccountActionLogic accountActionLogic, ClaimTransformLogic claimTransformLogic, LoginUpLogic loginUpLogic, LogoutUpLogic logoutUpLogic, SingleLogoutDownLogic singleLogoutDownLogic, OAuthRefreshTokenGrantDownLogic <OAuthDownClient, OAuthDownScope, OAuthDownClaim> oauthRefreshTokenGrantLogic) : base(logger)
{
this.logger = logger;
this.localizer = localizer;
this.tenantRepository = tenantRepository;
this.loginPageLogic = loginPageLogic;
this.sessionLogic = sessionLogic;
this.sequenceLogic = sequenceLogic;
this.securityHeaderLogic = securityHeaderLogic;
this.userAccountLogic = userAccountLogic;
this.accountActionLogic = accountActionLogic;
this.claimTransformLogic = claimTransformLogic;
this.loginUpLogic = loginUpLogic;
this.logoutUpLogic = logoutUpLogic;
this.singleLogoutDownLogic = singleLogoutDownLogic;
this.oauthRefreshTokenGrantLogic = oauthRefreshTokenGrantLogic;
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.Configure <CookiePolicyOptions>(options =>
{
// This lambda determines whether user consent for non-essential cookies is needed for a given request.
options.CheckConsentNeeded = context => true;
options.MinimumSameSitePolicy = SameSiteMode.None;
});
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1)
.AddDataAnnotationsLocalization();
services.AddMvcCore()
.AddDataAnnotations();
// Adds a default in-memory implementation of IDistributedCache.
services.AddDistributedMemoryCache();
services.AddSession();
//register catalog DB
services.AddDbContext <CatalogDbContext>(options => options.UseSqlServer(GetCatalogConnectionString(CatalogConfig, DatabaseConfig)));
//Add Application services
services.AddTransient <ICatalogRepository, CatalogRepository>();
services.AddTransient <ITenantRepository, TenantRepository>();
services.AddSingleton <ITenantRepository>(p => new TenantRepository(GetBasicSqlConnectionString()));
services.AddSingleton <IConfiguration>(Configuration);
services.AddSingleton <ILookupClient>(p => new LookupClient());
services.AddSingleton <IEmailService>(p => new EmailService());
services.AddAuthentication(CookieAuthenticationDefaults.AuthenticationScheme)
.AddCookie(options =>
{
options.LoginPath = "/Account/Login";
options.LogoutPath = "Account/Logout";
});
//create instance of utilities class
services.AddTransient <IUtilities, Utilities>();
var provider = services.BuildServiceProvider();
_utilities = provider.GetService <IUtilities>();
_catalogRepository = provider.GetService <ICatalogRepository>();
_tenantRepository = provider.GetService <ITenantRepository>();
_client = provider.GetService <ILookupClient>();
}
public TenantManager(ILogger <TenantManager> logger,
ITenantRepository tenantRepository,
ICompanyManager companyManager,
ICompanyTenantRepository companyTenantRepository,
ICompanyRepository companyRepository)
{
_logger = logger ??
throw new ArgumentNullException(nameof(logger));
_tenantRepository = tenantRepository ??
throw new ArgumentNullException(nameof(_tenantRepository));
_companyManager = companyManager ??
throw new ArgumentNullException(nameof(_companyManager));
_companyTenantRepository = companyTenantRepository ??
throw new ArgumentNullException(nameof(_companyTenantRepository));
_companyRepository = companyRepository ??
throw new ArgumentNullException(nameof(companyRepository));
}
public CreateRuleService(
ICreateRuleValidator createRuleValidator,
IConditionNodeAbstractFactory conditionNodeAbstractFactory,
IConditionTypeRepository conditionTypeRepository,
IContentTypeRepository contentTypeRepository,
IRuleFactory ruleFactory,
IRuleRepository ruleRepository,
ITenantRepository tenantRepository)
{
this.createRuleValidator = createRuleValidator;
this.conditionNodeAbstractFactory = conditionNodeAbstractFactory;
this.conditionTypeRepository = conditionTypeRepository;
this.contentTypeRepository = contentTypeRepository;
this.ruleFactory = ruleFactory;
this.ruleRepository = ruleRepository;
this.tenantRepository = tenantRepository;
}
private async Task <UpParty> GetUpPartyAsync(ITenantRepository tenantRepository, Track.IdKey trackIdKey, Group upPartyGroup)
{
var upPartyIdKey = new Party.IdKey
{
TenantName = trackIdKey.TenantName,
TrackName = trackIdKey.TrackName,
PartyName = upPartyGroup.Value,
};
try
{
return(await tenantRepository.GetUpPartyByNameAsync(upPartyIdKey));
}
catch (Exception ex)
{
throw new RouteCreationException($"Invalid tenantName '{upPartyIdKey.TenantName}', trackName '{upPartyIdKey.TrackName}' and upPartyName '{upPartyIdKey.PartyName}'.", ex);
}
}
private async Task <DownParty> GetDownPartyAsync(ITenantRepository tenantRepository, Track.IdKey trackIdKey, Group downPartyGroup, bool acceptUnknownParty)
{
var downPartyIdKey = new Party.IdKey
{
TenantName = trackIdKey.TenantName,
TrackName = trackIdKey.TrackName,
PartyName = downPartyGroup.Value,
};
try
{
return(await tenantRepository.GetDownPartyByNameAsync(downPartyIdKey, required : !acceptUnknownParty));
}
catch (Exception ex)
{
throw new RouteCreationException($"Invalid tenantName '{downPartyIdKey.TenantName}', trackName '{downPartyIdKey.TrackName}' and downPartyName '{downPartyIdKey.PartyName}'.", ex);
}
}
public StorageHub(ILogger <StorageHub> logger,
CredentialsConfiguration credentialsConfiguration,
IStorageHubRepository storageHubRepository,
ITenantRepository tenantMemoryRepository,
IStorageFactory storageFactory,
IAgentFactory agentFactory,
IConsumerHubService consumerHubService,
IProducerHubService producerHubService)
{
this.logger = logger;
this.credentialsConfiguration = credentialsConfiguration;
this.storageHubRepository = storageHubRepository;
this.tenantMemoryRepository = tenantMemoryRepository;
this.storageFactory = storageFactory;
this.agentFactory = agentFactory;
this.consumerHubService = consumerHubService;
this.producerHubService = producerHubService;
}
public IdentityApplicationService(
IUnitOfWork unitOfWork,
AuthenticationService authenticationService,
GroupMemberService groupMemberService,
IGroupRepository groupRepository,
TenantProvisioningService tenantProvisioningService,
ITenantRepository tenantRepository,
IUserRepository userRepository
)
{
this.unitOfWork = unitOfWork;
this.authenticationService = authenticationService;
this.groupMemberService = groupMemberService;
this.groupRepository = groupRepository;
this.tenantProvisioningService = tenantProvisioningService;
this.tenantRepository = tenantRepository;
this.userRepository = userRepository;
}
public async Task <IActionResult> Register(CancellationToken cancellationToken,
[System.Web.Http.FromBody] CreateTenantBinding binding,
[FromServices] TenantManager manager,
[FromServices] ITenantRepository repository)
{
var tenant = await repository.Get(binding.Name, binding.Surname, binding.Password, cancellationToken);
if (tenant != null)
{
return(BadRequest(new { errorText = "Invalid username or password." }));
}
try
{
tenant = await manager.Create(binding.Name,
binding.Surname,
binding.Password,
binding.DateOfBirth,
binding.Address,
binding.EntranceNumber,
binding.FlatNumber,
cancellationToken);
}
catch (BuildingWithSuchAddressNotRegisteredException e)
{
return(NotFound());
}
if (binding.Avatar != null)
{
byte[] avatarData = null;
using (var binaryReader = new BinaryReader(binding.Avatar.OpenReadStream()))
{
avatarData = binaryReader.ReadBytes((int)binding.Avatar.Length);
}
tenant.PutAvatar(avatarData);
}
await repository.Save(tenant);
return(await GetToken(tenant.TenatId));
}
public async Task Invoke(HttpContext context, ITenantIdentificationService tenantIdentificationService,
ITenantContextAccessor tenantContextAccessor, ITenantRepository tenantRepository, IOptions <TenancyHostingOptions> tenancyOptions)
{
if (tenancyOptions.Value.TenancyType == TenancyType.None)
{
await _next(context);
return;
}
if (tenantContextAccessor.TenantContext != null)
{
throw new ApplicationException("Tenant context is already set");
}
var tenantId = await tenantIdentificationService.GetTenantIdAsync();
var tenant = await tenantRepository.Get(tenantId, context.RequestAborted)
?? throw new ApplicationException($"Tenant {tenantId} not found");
if (tenant.IsShared && tenancyOptions.Value.TenancyType == TenancyType.MonoTenant)
{
throw new ApplicationException(
$"Received a message for shared tenant {tenantId} in a MonoTenant hosting");
}
if (!tenant.IsShared && tenancyOptions.Value.TenancyType == TenancyType.MultiTenant)
{
throw new ApplicationException(
$"Received a message for premium tenant {tenantId} in a MultiTenant (shared) context");
}
if (tenancyOptions.Value.TenancyType == TenancyType.MonoTenant && tenancyOptions.Value.TenantId != tenantId)
{
throw new ApplicationException(
$"Invalid tenant ID. Expected {tenancyOptions.Value.TenantId} but received {tenantId}");
}
tenantContextAccessor.TenantContext = new TenantContext(tenant);
await _next(context);
}
public TenantResolver(MasterDBContext context, IHttpContextAccessor accessor, IAliasRepository aliasrepository, ITenantRepository tenantrepository)
{
db = context;
_aliasrepository = aliasrepository;
_tenantrepository = tenantrepository;
// get alias based on request context
aliasname = accessor.HttpContext.Request.Host.Value;
string path = accessor.HttpContext.Request.Path.Value;
string[] segments = path.Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
if (segments.Length > 0 && segments[0] == "api" && segments[1] != "~")
{
aliasname += "/" + segments[1];
}
if (aliasname.EndsWith("/"))
{
aliasname = aliasname.Substring(0, aliasname.Length - 1);
}
}
public async Task<IActionResult> GetDetailForAdmin(long? id, [FromServices] ITenantRepository tenantRepository)
{
if (id == null)
{
return JsonBadRequest("Role ID is required.");
}
var role = await roleRepository.GetRoleAsync(id.Value);
if (role == null)
{
return JsonNotFound($"Node Id {id.Value} is not found.");
}
var model = new DetailsOutputModel(role);
if (model.TenantId != null)
{
model.TenantName = tenantRepository.Get(model.TenantId.Value).Name;
}
return JsonOK(model);
}
public async Task <IActionResult> DeleteForAdmin(long?id, [FromServices] ITenantRepository tenantRepository)
{
//データの入力チェック
if (id == null)
{
return(JsonBadRequest("Invalid inputs."));
}
//データの存在チェック
var role = await roleRepository.GetRoleAsync(id.Value);
if (role == null)
{
return(JsonNotFound($"Role ID {id.Value} is not found."));
}
await roleRepository.DeleteAsync(id.Value, unitOfWork);
unitOfWork.Commit();
return(JsonNoContent());
}
public static async Task <Tenant> CreateNewEntry(
ITenantRepository repository,
string name,
string displayName,
string description
)
{
if (string.IsNullOrWhiteSpace(name))
{
throw new ArgumentException("The tenant must be specified", nameof(name));
}
if (!Regex.IsMatch(name, "^(?=.{3,63}$)[a-z0-9]+(-[a-z0-9]+)*$"))
{
throw new ArgumentException("The tenant name must have 3 to 63 characters, start with an alphanumeric character and contain alphanumeric characters or hyphens only");
}
if (!await repository.HasUniqName(name))
{
throw new ArgumentException("An other tenant has the same name.", nameof(name));
}
if (!await repository.HasUniqArchivedName(name))
{
throw new ArgumentException("An archived tenant has the same name.", nameof(name));
}
var tenant = new Tenant
{
Id = Guid.NewGuid(),
Name = name,
DisplayName = displayName,
Description = description,
Enabled = true,
RegionId = TenantRegion.EUROPE.Id,
UsersNumber = 0
};
return(tenant);
}
public TenantManager(ITenantRepository tenantRepository,
ICompanyRepository companyRepository,
IBranchRepository branchRepository,
ISupplierRepository supplierRepository,
IWarehouseRepository warehouseRepository,
ISubscriptionRepository subscriptionRepository,
IEditionRepository editionRepository,
ICompanySettingsRepository companySettingsRepository,
ISubscriptionPaymentRepository subscriptionPaymentRepository,
ISmsService smsService,
ICustomerRepository customerRepository,
IUserService userService,
RoleManager roleManager,
IEmployeeRepository employeeRepository,
ISecurityRepository <Role, string> roleRepository)
{
_tenantRepository = tenantRepository;
_companyRepository = companyRepository;
_branchRepository = branchRepository;
_supplierRepository = supplierRepository;
_warehouseRepository = warehouseRepository;
_subscriptionRepository = subscriptionRepository;
_editionRepository = editionRepository;
_companySettingsRepository = companySettingsRepository;
_subscriptionPaymentRepository = subscriptionPaymentRepository;
_smsService = smsService;
_userService = userService;
_roleManager = roleManager;
_userManager = HttpContext.Current?.GetOwinContext()?.GetUserManager <UserManager>();
_employeeRepository = employeeRepository;
_roleRepository = roleRepository;
_customerRepository = customerRepository;
var tenantId = HttpContext.Current?.Request.Headers["TenantId"];
_userManager?.SetTenantId(string.IsNullOrWhiteSpace(tenantId) ? null : tenantId);
}
public TenantResolver(MasterDBContext context, IHttpContextAccessor accessor, IAliasRepository Aliases, ITenantRepository Tenants, SiteState sitestate)
{
db = context;
this.Aliases = Aliases;
this.Tenants = Tenants;
this.sitestate = sitestate;
aliasname = "";
// get alias based on request context
if (accessor.HttpContext != null)
{
// check if an alias is passed as a querystring parameter
if (accessor.HttpContext.Request.Query.ContainsKey("alias"))
{
aliasname = accessor.HttpContext.Request.Query["alias"];
}
else // get the alias from the request url
{
aliasname = accessor.HttpContext.Request.Host.Value;
string path = accessor.HttpContext.Request.Path.Value;
string[] segments = path.Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
if (segments.Length > 1 && segments[1] == "api" && segments[0] != "~")
{
aliasname += "/" + segments[0];
}
if (aliasname.EndsWith("/"))
{
aliasname = aliasname.Substring(0, aliasname.Length - 1);
}
}
}
else // background processes can pass in an alias using the SiteState service
{
if (sitestate != null)
{
aliasname = sitestate.Alias.Name;
}
}
}
public TenantController(
ITenantRepository tenantRepository,
IUserRepository userRepository,
IRoleRepository roleRepository,
IRegistryRepository registryRepository,
IGitRepository gitRepository,
ICommonDiLogic commonDiLogic,
IStorageLogic storageLogic,
IClusterManagementLogic clusterManagementLogic,
IUnitOfWork unitOfWork,
IHttpContextAccessor accessor) : base(accessor)
{
this.tenantRepository = tenantRepository;
this.userRepository = userRepository;
this.roleRepository = roleRepository;
this.registryRepository = registryRepository;
this.gitRepository = gitRepository;
this.commonDiLogic = commonDiLogic;
this.storageLogic = storageLogic;
this.clusterManagementLogic = clusterManagementLogic;
this.unitOfWork = unitOfWork;
}
public TenantResolver(MasterDBContext context, IHttpContextAccessor accessor, IAliasRepository Aliases, ITenantRepository Tenants)
{
db = context;
this.Aliases = Aliases;
this.Tenants = Tenants;
aliasname = "";
// get alias based on request context
if (accessor.HttpContext != null)
{
aliasname = accessor.HttpContext.Request.Host.Value;
string path = accessor.HttpContext.Request.Path.Value;
string[] segments = path.Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
if (segments.Length > 1 && segments[1] == "api" && segments[0] != "~")
{
aliasname += "/" + segments[0];
}
if (aliasname.EndsWith("/"))
{
aliasname = aliasname.Substring(0, aliasname.Length - 1);
}
}
}
public UserServsiceTest()
{
var mappingConfig = new MapperConfiguration(mc =>
{
mc.AddProfile(new AutoMapping());
});
_unitOfWork = new UnitOfWork("Server=localhost;Port=3306;User Id=root;Database=tenantdb");
_userRepository = new UserRepository(_unitOfWork);
_mapper = mappingConfig.CreateMapper();
_context = new DefaultHttpContext();
_httpContextAccessor = new HttpContextAccessor();
_httpContextAccessor.HttpContext = _context;
var hostString = new HostString("http://localhost:5000", 5000);
_httpContextAccessor.HttpContext.Request.Host = hostString;
_tenantRepository = new TenantRepository(_unitOfWork);
_tenantService = new TenantService(_tenantRepository, _mapper);
_userService = new UserService(_userRepository, _mapper);
_authAPIController = new AuthAPIController(_httpContextAccessor, _tenantService, _userService);
}
/// <summary>
/// コンストラクタ
/// </summary>
public PreprocessingController(
IPreprocessRepository preprocessRepository,
IPreprocessHistoryRepository preprocessHistoryRepository,
ITenantRepository tenantRepository,
IDataRepository dataRepository,
IPreprocessLogic preprocessLogic,
ITagLogic tagLogic,
IGitLogic gitLogic,
IStorageLogic storageLogic,
IClusterManagementLogic clusterManagementLogic,
IUnitOfWork unitOfWork,
IHttpContextAccessor accessor) : base(accessor)
{
this.preprocessRepository = preprocessRepository;
this.preprocessHistoryRepository = preprocessHistoryRepository;
this.tenantRepository = tenantRepository;
this.dataRepository = dataRepository;
this.preprocessLogic = preprocessLogic;
this.tagLogic = tagLogic;
this.gitLogic = gitLogic;
this.storageLogic = storageLogic;
this.clusterManagementLogic = clusterManagementLogic;
this.unitOfWork = unitOfWork;
}
/// <summary>
/// コンストラクタ
/// </summary>
public InferenceController(
ITrainingHistoryRepository trainingHistoryRepository,
IInferenceHistoryRepository inferenceHistoryRepository,
IDataSetRepository dataSetRepository,
ITenantRepository tenantRepository,
INodeRepository nodeRepository,
IInferenceLogic inferenceLogic,
IStorageLogic storageLogic,
IGitLogic gitLogic,
IClusterManagementLogic clusterManagementLogic,
IUnitOfWork unitOfWork,
IHttpContextAccessor accessor) : base(accessor)
{
this.trainingHistoryRepository = trainingHistoryRepository;
this.inferenceHistoryRepository = inferenceHistoryRepository;
this.dataSetRepository = dataSetRepository;
this.tenantRepository = tenantRepository;
this.nodeRepository = nodeRepository;
this.inferenceLogic = inferenceLogic;
this.storageLogic = storageLogic;
this.gitLogic = gitLogic;
this.clusterManagementLogic = clusterManagementLogic;
this.unitOfWork = unitOfWork;
}
/// <summary>
/// 初始化站点管理器
/// </summary>
/// <param name="tenantRepository">租户仓储</param>
protected SiteManagerBase( ITenantRepository tenantRepository ) {
TenantRepository = tenantRepository;
}
public PropertySignRequestManager(IPropertySignRequestRepository repository, ITenantRepository tenantRepository)
{
_repository = repository;
_tenantRepository = tenantRepository;
}
public TLoginUpPartyController(TelemetryScopedLogger logger, IMapper mapper, ITenantRepository tenantRepository, ValidateGenericPartyLogic validateGenericPartyLogic, ValidateLoginPartyLogic validateLoginPartyLogic) : base(logger, mapper, tenantRepository, validateGenericPartyLogic)
{
this.validateLoginPartyLogic = validateLoginPartyLogic;
}
public TenantService(ITenantRepository repository)
{
_repository = repository;
}
/// <summary>
/// 初始化应用程序管理器
/// </summary>
/// <param name="applicationRepository">应用程序仓储</param>
/// <param name="tenantRepository">租户仓储</param>
public ApplicationManager(IApplicationRepository applicationRepository, ITenantRepository tenantRepository)
{
ApplicationRepository = applicationRepository;
TenantRepository = tenantRepository;
}
public IdentityApplicationService(ITenantRepository tenantRepository)
{
_tenantRepository = tenantRepository;
}
public RouteBasedTenantResolverService(ITenantRepository tenants)
{
_tenants = tenants;
}
/// <summary>
/// 初始化站点管理器
/// </summary>
/// <param name="tenantRepository">租户仓储</param>
public SiteManager( ITenantRepository tenantRepository )
: base( tenantRepository ) {
}
public async Task <IActionResult> CreateForAdmin([FromBody] CreateInputModel model, [FromServices] ITenantRepository tenantRepository)
{
// データの入力チェック
if (!ModelState.IsValid)
{
return(JsonBadRequest("Invalid inputs."));
}
if (model.IsSystemRole && model.TenantId != null)
{
// Admin向けなのにテナント固有にしてあったら入力ミス
return(JsonBadRequest($"Invalid inputs. the role is for admin, but set to specific tenant { model.TenantId }"));
}
// データの存在チェック
if (model.TenantId != null && tenantRepository.Get(model.TenantId.Value) == null)
{
return(JsonNotFound($"Tenant ID {model.TenantId.Value} is not found."));
}
return(await CreateAsync(model));
}
public TenantService(ITenantRepository tenantRepository)
{
this._tenantRepository = tenantRepository;
}
public TenantService(ITenantRepository repository) : base(repository)
{
_repository = repository;
}
public HostBasedTenantResolverService(ITenantRepository tenants)
{
_tenants = tenants;
_hosts = new Dictionary<string,Tenant>();
}
