public TransactionOrderDomainEntity(
ICoreContext coreContext,
ITransactionOrderRepository transactionOrderRepository)
{
this.coreContext = coreContext;
this.transactionOrderRepository = transactionOrderRepository;
}
public AccountManager(
ICoreContext coreContext)
{
this.coreContext = coreContext;
this.coreContext.Logger.Info("AccountManager created.", this.coreContext.GetContainerInfo());
}
public AccountController(ICoreContext coreContext, IIdentityServerInteractionService identityService, IAuthenticationSchemeProvider schemeProvider, IEventService eventService, IClientStore clientStore) : base(coreContext)
{
this.clientStore = clientStore;
this.eventService = eventService;
this.identityService = identityService;
this.schemeProvider = schemeProvider;
}
public CreditCardExtreDischargeDomainEntity(
ICoreContext coreContext,
ICreditCardExtreDischargeRepository creditCardExtreDischargeRepository)
{
this.coreContext = coreContext;
this.creditCardExtreDischargeRepository = creditCardExtreDischargeRepository;
}
public override void SetUp()
{
base.SetUp();
objectRepository = new Dictionary <string, object>();
codingStyle = BuildRoutine.CodingStyle().FromBasic()
.AddTypes(GetType().Assembly, t => t.IsPublic && t.Namespace != null && t.Namespace.StartsWith(RootNamespace))
.Initializers.Add(c => c.Constructors().When(t => t.IsValueType && t.Namespace?.StartsWith(RootNamespace) == true))
.Datas.Add(c => c.PublicProperties(m => !m.IsInherited()).When(t => t.Namespace?.StartsWith(RootNamespace) == true))
.Operations.Add(c => c.PublicMethods(m => !m.IsInherited()).When(t => t.Namespace?.StartsWith(RootNamespace) == true))
.IdExtractor.Set(c => c.IdByProperty(p => p.Returns <string>("Id")).When(t => t.Namespace != null && t.Namespace.StartsWith(RootNamespace)))
.Locator.Set(c => c.Locator(l => l.SingleBy(id => objectRepository[id])).When(t => t.Namespace != null && t.Namespace.StartsWith(RootNamespace) && t.Properties.Any(m => m.Returns <string>("Id"))))
.NextLayer()
;
var cache = new DictionaryCache();
ctx = new DefaultCoreContext(codingStyle, cache);
testing = new ObjectService(ctx, cache);
}
public CreditCardDomainEntity(
ICoreContext coreContext,
ICreditCardRepository creditCardRepository)
{
this.coreContext = coreContext;
this.creditCardRepository = creditCardRepository;
}
public AccountTransactionDomainEntity(
ICoreContext coreContext,
IAccountTransactionRepository accountTransactionRepository)
{
this.coreContext = coreContext;
this.accountTransactionRepository = accountTransactionRepository;
}
public AccountDomainEntity(
ICoreContext coreContext,
IAccountRepository accountRepository)
{
this.coreContext = coreContext;
this.accountRepository = accountRepository;
}
public LoginController(ICoreContext coreContext, ILoginService loginService, IStringLocalizer <VbtController> localizer, IWorkContext workContext)
{
_coreContext = coreContext;
_loginService = loginService;
_localizer = localizer;
_workContext = workContext;
}
public CompanyManager(
ICoreContext coreContext, PersonManager personManager, AccountManager accountManager)
{
this.coreContext = coreContext;
this.personManager = personManager;
this.accountManager = accountManager;
}
public static ICoreContext GetLifelistProject(this LifelistPNVBrowserExtension browser)
{
ICoreContext context = Reflector.GetInstancePropertyByName(browser, "LifelistProject",
ReflectionWays.SystemReflection) as ICoreContext;
return(context);
}
public LoginService(IEncryptionService encryptionService, IRepository <DB.Entities.Users> userRepository, IUserService userService, IRedisCacheService redisCacheService, ICoreContext coreContext)
{
_encryptionService = encryptionService;
_userRepository = userRepository;
_userService = userService;
_redisCacheService = redisCacheService;
_coreContext = coreContext;
}
public static ICoreObject CreateTempControllerTarget(this ICoreContext projectContext,
string configObjectTypeName, string plcName)
{
return(Reflector.RunStaticMethodByName(typeof(BLBlockProcessor),
"CreateTempControllerTarget",
ReflectionWays.SystemReflection,
projectContext, configObjectTypeName, plcName) as ICoreObject);
}
public PersonDomainEntity(
IPersonRepository personRepository, ICoreContext coreContext)
{
this.coreContext = coreContext;
this.personRepository = personRepository;
this.coreContext.Logger.Info("PersonDomainEntity created.", this.coreContext.GetContainerInfo());
}
public LoginFilter(IRedisCacheService redisCacheService, IEncryptionService encryptionService,
IUserService userService, ICoreContext coreContext, IWorkContext workContext)
{
_redisCacheService = redisCacheService;
_encryptionService = encryptionService;
_coreContext = coreContext;
_userService = userService;
_workContext = workContext;
}
public CreditCardManager(
ICoreContext coreContext,
AccountManager accountManager,
CompanyManager companyManager)
{
this.coreContext = coreContext;
this.accountManager = accountManager;
this.companyManager = companyManager;
}
public Query(ICoreContext coreContext, IJsonReader jsonReader)
{
//string appDir = System.AppContext.BaseDirectory;
//var dataSourceDir = System.IO.Directory.GetParent(appDir).Parent.Parent.Parent;
//string dataSourceFileName = string.Concat(dataSourceDir.FullName, @"\dataSource\",
// typeof(T).Name.ToLower(), "s.json");
this.jsonReader = jsonReader;
}
public TransactionManager(
ICoreContext coreContext,
AccountManager accountManager,
CreditCardManager creditCardManager)
{
this.coreContext = coreContext;
this.accountManager = accountManager;
this.creditCardManager = creditCardManager;
}
public KontentRepository(
HttpClient httpClient,
ICoreContext coreContext,
Settings settings
)
{
this.httpClient = httpClient;
this.coreContext = coreContext;
this.settings = settings;
}
public StorageRepository(
IEncryptionService encryptionService,
ICoreContext coreContext,
Settings settings
)
{
this.encryptionService = encryptionService;
this.coreContext = coreContext;
this.settings = settings;
}
public CreateTransfer(
ILogger <CreateTransfer> logger,
IAccessTokenValidator accessTokenValidator,
ITransfersService transfersService,
ICoreContext coreContext
) : base(logger)
{
this.accessTokenValidator = accessTokenValidator;
this.transfersService = transfersService;
this.coreContext = coreContext;
}
public ProcessContainers(
ILogger <ProcessContainers> logger,
IStorageRepository storageRepository,
ITransfersService transfersService,
ICoreContext coreContext
) : base(logger)
{
this.storageRepository = storageRepository;
this.transfersService = transfersService;
this.coreContext = coreContext;
}
public KontentWebhook(
ILogger <KontentWebhook> logger,
IWebhookValidator webhookValidator,
IStorageRepository storageRepository,
ICoreContext coreContext
) : base(logger)
{
this.webhookValidator = webhookValidator;
this.storageRepository = storageRepository;
this.coreContext = coreContext;
}
public LoginFilter(IRedisCacheService redisCacheService, IEncryption encryption,
IUserService userService, ICoreContext coreContext, IWorkContext workContext, IRoleService roleService, IStringLocalizer <VbtController> localizer)
{
_redisCacheService = redisCacheService;
_encryption = encryption;
_coreContext = coreContext;
_userService = userService;
_workContext = workContext;
_roleService = roleService;
_localizer = localizer;
}
public DomainObjectInitializer(ICoreContext ctx, IConstructor constructor)
{
this.ctx = ctx;
groups = new List <DomainParameter.Group <IConstructor> >();
Parameter = new Dictionary <string, DomainParameter>();
Marks = new Marks();
AddGroup(constructor);
}
public TransferFileProxy(
ILogger <TransferFileProxy> logger,
IAccessTokenValidator accessTokenValidator,
ICoreContext coreContext,
HttpClient httpClient,
Settings settings
) : base(logger)
{
this.accessTokenValidator = accessTokenValidator;
this.coreContext = coreContext;
this.httpClient = httpClient;
this.settings = settings;
}
public TransfersService(
IKontentRepository kontentRepository,
IStorageRepository storageRepository,
ITeamsService teamsService,
ICoreContext coreContext,
Settings settings
)
{
this.kontentRepository = kontentRepository;
this.storageRepository = storageRepository;
this.teamsService = teamsService;
this.coreContext = coreContext;
this.settings = settings;
}
private DomainParameter(ICoreContext ctx, IParameter parameter, int initialGroupIndex)
{
this.ctx = ctx;
this.parameter = parameter;
Name = ctx.CodingStyle.GetName(parameter);
ParameterType = ctx.GetDomainType(Fix(parameter.ParameterType));
Marks = new Marks(ctx.CodingStyle.GetMarks(parameter));
Groups = new List <int> {
initialGroupIndex
};
IsList = parameter.ParameterType.CanBeCollection();
IsOptional = ctx.CodingStyle.IsOptional(parameter);
defaultValue = ctx.CodingStyle.GetDefaultValue(parameter);
}
public DomainType(ICoreContext ctx, IType type)
{
this.ctx = ctx;
Type = type;
Data = new Dictionary <string, DomainData>();
Operation = new Dictionary <string, DomainOperation>();
Marks = new Marks(ctx.CodingStyle.GetMarks(Type));
Name = ctx.CodingStyle.GetName(Type);
Module = ctx.CodingStyle.GetModule(Type);
Id = ctx.BuildTypeId(Module, Name);
MaxFetchDepth = ctx.CodingStyle.GetMaxFetchDepth();
locator = ctx.CodingStyle.GetLocator(Type);
IdExtractor = ctx.CodingStyle.GetIdExtractor(Type);
ValueExtractor = ctx.CodingStyle.GetValueExtractor(Type);
converter = new Dictionary <IType, IConverter>();
var converters = ctx.CodingStyle.GetConverters(Type);
foreach (var converterInstance in converters)
{
foreach (var targetType in converterInstance.GetTargetTypes(Type))
{
if (converter.ContainsKey(targetType))
{
continue;
}
converter.Add(targetType, converterInstance);
}
}
staticInstances = ctx.CodingStyle.GetStaticInstances(Type);
IsValueModel = ctx.CodingStyle.IsValue(Type);
IsViewModel = ctx.CodingStyle.IsView(Type);
actualTypes = new List <DomainType>();
viewTypes = new List <DomainType>();
}
public DomainData(ICoreContext ctx, IProperty property)
{
this.ctx = ctx;
this.property = property;
Name = ctx.CodingStyle.GetName(property);
Marks = new Marks(ctx.CodingStyle.GetMarks(property));
IsList = property.ReturnType.CanBeCollection();
FetchedEagerly = ctx.CodingStyle.IsFetchedEagerly(property);
var returnType = IsList ? property.ReturnType.GetItemType() : property.ReturnType;
if (!ctx.CodingStyle.ContainsType(returnType))
{
throw new TypeNotConfiguredException(returnType);
}
DataType = ctx.GetDomainType(returnType);
}
