public void EditActivity(IDomainContext context, Activity activity)
{
var window = new EditActivityWindow();
window.ViewModel.DomainContext = context;
window.ViewModel.Activity = activity;
ShowCustomDialog(window);
}
public EarnViewController(IDomainContext context, MinionId minionId, decimal defaultAllowance)
: base("EarnViewController", null)
{
this.context = context;
this.minionId = minionId;
this.defaultAllowance = defaultAllowance;
}
public ReadModelBuilderAgent(IDomainContext context,
List<IAggregateRegistration> registrations, Func<IUnitOfWorkScope> scopeFactory, Func<IUnitOfWorkScope, IReadModelQueue> queueFactory)
{
this.context = context;
this.registrations = registrations;
this.queueFactory = queueFactory;
this.scopeFactory = scopeFactory;
this.maxItems = 50;
}
public async Task CanSendCommandsToMultipleHandlersOnDifferentContexts(int nContexts)
{
// arrange
var subscriptionStore = new LocalSubscriptionStore(); // shared store
var subscriptionBroker = new LocalSubscriptionBroker(); // shared broker
var transportFactory = new LocalTransportFactory(); // shared transport
var syncs = new CountdownEvent[nContexts];
var contexts = new IDomainContext[nContexts];
for (var i = 0; i < nContexts; ++i)
{
var idx = i;
syncs[i] = new CountdownEvent(2);
contexts[i] = DomainContext.Configure()
.Bus(b =>
b.WithCustomSubscriptionStore(subscriptionStore)
.WithCustomSubscriptionBroker(subscriptionBroker)
.WithCustomTransportFactory(transportFactory)
.WithProcessor(p =>
p.Endpoint("p" + idx)
.RegisterHandler(new TestCommandHandler(cmd => syncs[idx].Signal())
))
)
.Start();
}
try
{
// doesnt really matter which ctx sends the messages, they know about eachother subscriptions
var ctx1 = contexts.First();
var ctx2 = contexts.Last();
await ctx1.CommandBus.Send(new Command<DoSimple>("cmd1", new DoSimple { }));
await ctx2.CommandBus.Send(new Command<DoComplex>("cmd2", new DoComplex { }));
foreach (var sync in syncs)
{
sync.Wait(TimeSpan.FromSeconds(2));
}
}
finally
{
foreach (var context in contexts)
{
context.Dispose();
}
}
// assert
foreach (var sync in syncs)
{
// asserts all messages were received by each processor
Assert.AreEqual(0, sync.CurrentCount);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="PersonalLocationsController"/> class.
/// </summary>
public PersonalLocationsController(
[CreateNew] IDomainContext domainContext,
[ServiceDependency] IGeoLocationServiceAgent geoLocationService
)
{
this.logWriter = EnterpriseLibraryContainer.Current.GetInstance<LogWriter>();
this.traceManager = new TraceManager(this.logWriter);
this.geoLocationService = geoLocationService;
this.domainContext = domainContext;
}
public MonitorBehaviorFactory(ILoggingConfiguration configuration, IDomainContext context, IRulesCompiler compiler)
{
var application = context.Applications.Get(configuration.ApplicationId);
var result = compiler.Compile(application.LoggingRules);
if (!result.Success)
{
var messages = result.Errors.Select(x => "{0} ({1},{2})".Args(x.Message, x.Line, x.Column)).ToArray();
throw new RulesCompilationException(String.Join(" | ", messages));
}
_rules = new List<IRule>(result.Rules);
}
public Activity CreateActivity(IDomainContext context)
{
Activity activity = null;
var window = new CreateActivityWindow();
var dialogResult = ShowCustomDialog(window);
if(dialogResult.HasValue && dialogResult.Value)
{
MessageBus.SendMessage(Unit.Default, Notifications.ActivityCreated);
}
return null;
}
public MainViewController(IDomainContext context, IRepository<MinionContract> repository, ITransactionRepository transactionRepository)
: base("MainViewController", null)
{
this.context = context;
this.repository = repository;
this.transactionRepository = transactionRepository;
this.lifetime = new CompositeDisposable();
// TODO: observe deleted events and name changes
// this.lifetime.Add(this.context.EventBus.Subscribe<IEvent>(this.OnNextEvent));
}
public InventoryController(
[ServiceDependency] ILcboInventoryService lcboService,
[ServiceDependency] ILcboStoresService lcboStoresService,
[CreateNew] IDomainContext domainContext
)
{
this.lcboService = lcboService;
this.lcboStoresService = lcboStoresService;
this.logWriter = EnterpriseLibraryContainer.Current.GetInstance<LogWriter>();
this.traceManager = new TraceManager(this.logWriter);
this.domainContext = domainContext;
}
public SettingsViewController(IDomainContext context, IRepository<MinionContract> repository)
: base(UITableViewStyle.Plain, new SettingsSource())
{
this.context = context;
this.repository = repository;
this.lifetime = new CompositeDisposable();
this.commandExecutor = context.NewCommandExecutor<MinionAggregate>();
this.NavigationItem.Title = "Settings";
this.NavigationItem.RightBarButtonItem = new UIBarButtonItem(UIBarButtonSystemItem.Edit, this.Edit);
this.NavigationItem.RightBarButtonItem.Enabled = false;
}
public IEnumerable<int> GetStoreNumbersToFind(IDomainContext domainContext, User userEntity)
{
IEnumerable<int> storeIds;
if (this.StoreNumberType == StoreNumberType.AllStores)
{
storeIds = from s in domainContext.Stores select s.Id;
}
else
{
if (this.StoreNumberType == StoreNumberType.AllUsersStores)
{
storeIds = from s in userEntity.Stores select s.Id;
}
else
{
storeIds = new int[] { this.StoreNumber };
}
}
return storeIds;
}
/// <inheritdoc />
public IDomainService Create(IDomainContext domainContext, IUnitOfWorkContextFactory uowContextFactory)
{
return(CreateDomainServiceFunc.Invoke(domainContext, uowContextFactory));
}
public FacultyViewModel(IDomainContext context) : base(context, new FacultyModel(context))
{
EditModeHeader = "Редактирование записи факультета";
ReadOnlyHeader = "Просмотр записи факультета";
EditLabel = ReadOnlyHeader;
}
public UserService(IDomainContext domainContext)
{
_domainContext = domainContext;
}
public ProjectPackageUtility(IDomainContext context)
{
this.context = context;
}
public DomainCommandExecutor(IDomainContext context)
{
this.context = context;
}
public ILocalizationDictionary CreateDictionary(IDomainContext context)
{
return(LocalizationDictionary.Create(this.resolver, context.Culture, context.SourceTimeZone));
}
public static void LoadNavigation <TKey, TEntity>(
IDomainContext domainContext, IEnumerable <TEntity> entities, IEnumerable <string> propertyNames)
where TEntity : class, IEntity <TKey>
{
var entitiesByType = entities.GroupBy(e => e.GetType()).ToList();
foreach (var entitiesOfType in entitiesByType)
{
var entityType = entitiesOfType.Key;
var props = entityType.GetProperties(BindingFlags.Public | BindingFlags.Instance)
.Where(p => propertyNames.Contains(p.Name)).ToList();
foreach (var navProp in props)
{
if (!navProp.CanRead || !navProp.CanWrite || navProp.GetIndexParameters().Any())
{
continue;
}
var navAttr = navProp.GetCustomAttribute(typeof(NavigationAttribute)) as NavigationAttribute;
if (navAttr == null || string.IsNullOrEmpty(navAttr.IdPropertyName) || navAttr.EntitySetItemType == null)
{
continue;
}
var idProp = entityType.GetProperty(navAttr.IdPropertyName);
if (!idProp.CanRead || !idProp.CanWrite || idProp.GetIndexParameters().Any())
{
continue;
}
var isCollection = (navProp.PropertyType.GetInterface("IEnumerable") != null);
var set = domainContext.EntitySets.Where(s => s.EntityType == navAttr.EntitySetItemType).FirstOrDefault();
if (set == null)
{
continue;
}
if (!isCollection)
{
var idType = idProp.PropertyType;
var defaultId = idType.IsValueType ? Activator.CreateInstance(idType) : null;
foreach (var entity in entitiesOfType)
{
var id = idProp.GetValue(entity, null);
if (id == defaultId)
{
continue;
}
var obj = set.Get(id);
navProp.SetValue(entity, obj, null);
}
}
else
{
foreach (var entity in entitiesOfType)
{
var id = idProp.GetValue(entity, null);
var ids = id as IEnumerable;
var objs = set.Get(ids);
navProp.SetValue(entity, objs, null);
}
}
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="TaskListRepository"/> class.
/// </summary>
/// <param name="context">The context.</param>
public TaskListRepository(IDomainContext context)
: base(context)
{
}
public ProcessRunner(IDomainContext context = null)
{
this.context = context;
Output = context?.Output;
}
public HighSchoolModel(IDomainContext domainContext) : base(domainContext, new HighSchoolSearchCriteria())
{
employeesIsLoaded = false;
employeesForSearchIsLoaded = false;
}
public SpendViewController(IDomainContext context, MinionId minionId)
: base("SpendViewController", null)
{
this.context = context;
this.minionId = minionId;
}
public ChairViewModel(IDomainContext context) : base(context, new ChairModel(context))
{
EditModeHeader = "Редактирование записи кафедры";
ReadOnlyHeader = "Просмотр записи кафедры";
EditLabel = ReadOnlyHeader;
}
private void OnActivitySelected(Activity activity, IDomainContext context)
{
PendingActivity = activity;
PendingDomainContext = context;
if (State != TimerState.Sprint && State != TimerState.HomeStraight)
{
CurrentActivity = activity;
CurrentDomainContext = context;
}
}
/// <summary>
/// Because Membership Providers outlive the request lifetime, don't have Ninject dispose of
/// the DomainContext. Also,
/// </summary>
/// <param name="domainContext"></param>
public CustomMembershipProviderService([Named("Transient")] IDomainContext domainContext)
{
this._domainContext = domainContext;
}
public void Handle(IDomainContext context)
{
_metrics.Add(context);
}
public EnvironmentService(IDomainContext domainContext, IUrlService urlService)
{
this._domainContext = domainContext;
this._urlService = urlService;
}
public ProductRepository(IDomainContext context)
{
_context = context;
}
public DomainService(IDomainContext context, IDataAccessWriteService writeService)
{
_context = context;
WriteService = writeService;
}
public EnvironmentsController(IDomainContext domainContext)
{
_domainContext = domainContext;
}
public ProcessClient(IDomainContext context)
{
this.context = context;
}
public static void SaveNavigation <TKey, TEntity>(
IDomainContext domainContext, IEntitySet <TKey, TEntity> entitySet,
IEnumerable <TEntity> entities, IEnumerable <string> propertyNames)
where TEntity : class, IEntity <TKey>
{
var entitiesByType = entities.GroupBy(e => e.GetType()).ToList();
foreach (var entitiesOfType in entitiesByType)
{
var entityType = entitiesOfType.Key;
var props = entityType.GetProperties(BindingFlags.Public | BindingFlags.Instance)
.Where(p => propertyNames.Contains(p.Name)).ToList();
foreach (var navProp in props)
{
if (!navProp.CanRead || !navProp.CanWrite || navProp.GetIndexParameters().Any())
{
continue;
}
var navAttr = navProp.GetCustomAttribute(typeof(NavigationAttribute)) as NavigationAttribute;
if (navAttr == null || string.IsNullOrEmpty(navAttr.IdPropertyName) || navAttr.EntitySetItemType == null)
{
continue;
}
var idProp = entityType.GetProperty(navAttr.IdPropertyName);
if (!idProp.CanRead || !idProp.CanWrite || idProp.GetIndexParameters().Any())
{
continue;
}
var isCollection = (navProp.PropertyType.GetInterface("IEnumerable") != null);
var idType = idProp.PropertyType;
if (isCollection)
{
var idTypeArgs = idType.GetGenericArguments();
if (idTypeArgs.Count() != 1)
{
continue;
}
idType = idTypeArgs.First();
}
var defaultId = idType.IsValueType ? Activator.CreateInstance(idType) : null;
var set = domainContext.EntitySets.Where(s => s.EntityType == navAttr.EntitySetItemType).FirstOrDefault();
if (set == null)
{
continue;
}
var subEntityType = navProp.PropertyType;
if (isCollection)
{
var subEntityTypeArgs = subEntityType.GetGenericArguments();
if (subEntityTypeArgs.Count() != 1)
{
continue;
}
subEntityType = subEntityTypeArgs.First();
}
var subEntityIdProp = subEntityType.GetProperty("Id", BindingFlags.Public | BindingFlags.Instance);
if (!isCollection)
{
foreach (var entity in entitiesOfType)
{
var obj = navProp.GetValue(entity, null) as IEntity;
if (obj == null)
{
idProp.SetValue(entity, defaultId, null);
continue;
}
var id = subEntityIdProp.GetValue(obj, null);
set.AddOrUpdate(obj);
idProp.SetValue(entity, id, null);
}
}
else
{
foreach (var entity in entitiesOfType)
{
var obj = navProp.GetValue(entity, null);
var objs = obj as IEnumerable <object>;
var ids = typeof(List <>).MakeGenericType(idType).GetConstructor(System.Type.EmptyTypes).Invoke(new object[0]) as IList;
if (objs != null)
{
foreach (IEntity o in objs)
{
var id = subEntityIdProp.GetValue(o, null);
set.AddOrUpdate(o);
ids.Add(id);
}
}
idProp.SetValue(entity, ids, null);
}
}
}
}
entitySet.Update(entities);
}
internal WebSiteTools(IDomainContext context, ServerManager server)
{
this.Context = context;
this.Server = server;
}
/// <summary>
/// Initializes a new instance of the <see cref="PGPUnitOfWork"/> class.
/// </summary>
/// <param name="domainContext">The domain context.</param>
public PGPUnitOfWork(IDomainContext domainContext)
{
m_domainContext = domainContext;
}
public static Task ExecuteRemove <T>(this EntityDomainService <T> domain, IDomainContext context)
where T : class, IEntity, new()
{
return(domain.ExecuteAsync <IDatabaseContext, IAuthenticationProvider, IValueProvider, EntityDomainAuthorizeOption>(context, domain.Remove));
}
/// <summary>
/// Initializes a new instance of the ScheduledPaymentLibrary class.
/// </summary>
/// <param name="context"></param>
public User(IDomainContext context)
{
this.Context = context;
}
public void EditActivity(IDomainContext context, Activity activity)
{
}
public ApplicationPublisher(IDomainContext context)
{
this.context = context;
}
internal WebApplicationTools(IDomainContext context, ServerManager server)
{
this.Context = context;
this.Server = server;
}
public CategoryRepository(IDomainContext domainContext)
{
_domainContext = domainContext;
}
public static Task <IViewModel <TModel> > ExecuteListViewModel <T, TModel>(this EntityDomainService <T> domain, IDomainContext context, Expression <Func <T, bool> > whereExpression, Expression <Func <T, TModel> > selectExpression)
where T : class, IEntity, new()
where TModel : class
{
context.EventManager.AddAsyncEventHandler <EntityQueryEventArgs <T> >(EntityDomainService <T> .EntityQueryEvent, (d, e) =>
{
e.Queryable = e.Queryable.Where(whereExpression);
return(Task.CompletedTask);
});
context.Options.SetOption(new EntityQuerySelectOption <T, TModel>(selectExpression));
return(domain.ExecuteAsync <IDatabaseContext, IAuthenticationProvider, EntityDomainAuthorizeOption, EntityQuerySelectOption <T, TModel>, IViewModel <TModel> >(context, domain.ListViewModel));
}
public EmployeeViewModel(IDomainContext context) : base(context, new EmployeeModel(context))
{
EditModeHeader = "Редактирование записи работника";
ReadOnlyHeader = "Просмотр записи работника";
EditLabel = ReadOnlyHeader;
}
public ActivityProcessor(IDomainContext context, IEmailNotification notification)
{
_context = context;
_notification = notification;
}
/// New up a GeneralRepository. Don't do this directly - have Ninject take care of it (conventions depend on it).
/// </summary>
/// <param name="domainContext">Uses a contextual binding to identify that we want the version of the
/// DomainContext that is scoped to the request (every use with this name will be the same instance
/// within the request. Membership/Role/Filter providers have different lifetimes and need transient scope.
/// https://github.com/ninject/ninject/wiki/Contextual-Binding </param>
public GeneralRepository([Named("RequestScope")] IDomainContext domainContext)
{
this._domainContext = domainContext;
this.DomainContext = this._domainContext;
}
public GeneralRepository(IDomainContext domainContext)
{
this._domainContext = domainContext;
this.DomainContext = this._domainContext;
}
public static Task <IViewModel <TModel> > ExecuteListViewModel <T, TModel>(this EntityDomainService <T> domain, IDomainContext context, Expression <Func <T, TModel> > selectExpression)
where T : class, IEntity, new()
where TModel : class
{
context.Options.SetOption(new EntityQuerySelectOption <T, TModel>(selectExpression));
return(domain.ExecuteAsync <IDatabaseContext, IAuthenticationProvider, EntityDomainAuthorizeOption, EntityQuerySelectOption <T, TModel>, IViewModel <TModel> >(context, domain.ListViewModel));
}
public PrivilegesViewModelAssembler(IDomainContext context)
{
_context = context;
}
public static Task <IEntityEditModel <T> > ExecuteCreate <T>(this EntityDomainService <T> domain, IDomainContext context)
where T : class, IEntity, new()
{
return(domain.ExecuteAsync <IDatabaseContext, IAuthenticationProvider, EntityDomainAuthorizeOption, IEntityEditModel <T> >(context, domain.Create));
}
public ItemsController(IDomainContext domainContext, IJsService jsService)
{
_domainContext = domainContext;
_jsService = jsService;
}
public SecurityService(IDomainContext context, ISession session)
{
_context = context;
_session = session;
}
public DomainsApiController(ICremaHost cremaHost) : base(cremaHost)
{
this.cremaHost = cremaHost;
this.domainContext = cremaHost.GetService(typeof(IDomainContext)) as IDomainContext;
}
public HighSchoolViewModel(IDomainContext context) : base(context, new HighSchoolModel(context))
{
EditModeHeader = "Редактирование записи учебного заведения";
ReadOnlyHeader = "Просмотр записи учебного заведения";
EditLabel = ReadOnlyHeader;
}
public SiteMenuService(IDomainContext context, IUrlService urlService)
{
this._domainContext = context;
this._urlService = urlService;
}
/// <summary>
/// Initializes a new instance of the <see cref="PGPUnitOfWork"/> class.
/// </summary>
/// <param name="domainContext">The domain context.</param>
public PGPUnitOfWork(IDomainContext domainContext)
{
m_domainContext = domainContext;
}
public MongoDatabaseInitializer(IMongoDatabaseManager manager, IDomainContext context)
{
_manager = manager;
_context = context;
}
