public ChatWindowViewModel(Conversation conversation, IServiceRegistry serviceRegistry)
: base(serviceRegistry)
{
if (!IsInDesignMode)
{
userRepository = ServiceRegistry.GetService <RepositoryManager>().GetRepository <User>();
participationRepository = (ParticipationRepository)ServiceRegistry.GetService <RepositoryManager>().GetRepository <Participation>();
clientService = ServiceRegistry.GetService <IClientService>();
Participation participation = participationRepository.GetParticipationByUserIdandConversationId(clientService.ClientUserId, conversation.Id);
groupChat = new GroupChatModel(participation);
contributionMessageFormatter = new ContributionMessageFormatter(clientService.ClientUserId, userRepository);
userRepository.EntityAdded += OnUserChanged;
userRepository.EntityUpdated += OnUserChanged;
ServiceRegistry.GetService <RepositoryManager>().GetRepository <Conversation>().EntityUpdated += OnConversationUpdated;
participationRepository.EntityUpdated += OnParticipationUpdated;
AddUserCommand = new AddUserToConversationCommand(this);
groupChat.Conversation = conversation;
groupChat.Users = GetUsers();
UpdateConnectedUsersList();
groupChat.WindowTitle = userRepository.FindEntityById(clientService.ClientUserId).Username;
groupChat.Title = GetChatTitle();
}
}
public static EasyAccessRepositoryAdapter <TEntityId, TEntityVersion, TEntity, TContext> Create <TEntityId, TEntityVersion, TEntity, TContext>(
IReadOnlyEntityRepository <TEntityId, TEntityVersion, TEntity, TContext> readRepository,
IBatchWriteOnlyEntityRepository <TEntityId, TEntityVersion, TEntity, TContext> writeRepository,
ISynchronizationContextFactory <TContext> contextFactory)
{
return(new EasyAccessRepositoryAdapter <TEntityId, TEntityVersion, TEntity, TContext>(readRepository, writeRepository, contextFactory));
}
public Synchronizer(
IReadOnlyEntityRepository <TAtypeEntityId, TAtypeEntityVersion, TAtypeEntity, TContext> atypeRepository,
IReadOnlyEntityRepository <TBtypeEntityId, TBtypeEntityVersion, TBtypeEntity, TContext> btypeRepository,
IBatchWriteOnlyEntityRepository <TAtypeEntityId, TAtypeEntityVersion, TAtypeEntity, TContext> atypeWriteRepository,
IBatchWriteOnlyEntityRepository <TBtypeEntityId, TBtypeEntityVersion, TBtypeEntity, TContext> btypeWriteRepository,
IInitialSyncStateCreationStrategy <TAtypeEntityId, TAtypeEntityVersion, TAtypeEntity, TBtypeEntityId, TBtypeEntityVersion, TBtypeEntity, TContext> initialSyncStateCreationStrategy,
IEntityRelationDataAccess <TAtypeEntityId, TAtypeEntityVersion, TBtypeEntityId, TBtypeEntityVersion> entityRelationDataAccess,
IEntityRelationDataFactory <TAtypeEntityId, TAtypeEntityVersion, TBtypeEntityId, TBtypeEntityVersion> entityRelationDataFactory,
IInitialEntityMatcher <TAtypeEntityId, TAtypeEntityVersion, TAtypeEntity, TBtypeEntityId, TBtypeEntityVersion, TBtypeEntity> initialEntityMatcher,
IEqualityComparer <TAtypeEntityId> atypeIdComparer, IEqualityComparer <TBtypeEntityId> btypeIdComparer,
ITotalProgressFactory totalProgressFactory,
IEqualityComparer <TAtypeEntityVersion> atypeVersionComparer,
IEqualityComparer <TBtypeEntityVersion> btypeVersionComparer, IEntitySyncStateFactory <TAtypeEntityId, TAtypeEntityVersion, TAtypeEntity, TBtypeEntityId, TBtypeEntityVersion, TBtypeEntity, TContext> syncStateFactory,
ISynchronizationInterceptorFactory <TAtypeEntityId, TAtypeEntityVersion, TAtypeEntity, TBtypeEntityId, TBtypeEntityVersion, TBtypeEntity, TContext> synchronizationInterceptorFactory = null)
{
_initialSyncStateCreationStrategy = initialSyncStateCreationStrategy;
_totalProgressFactory = totalProgressFactory;
_atypeIdComparer = atypeIdComparer;
_btypeIdComparer = btypeIdComparer;
_atypeVersionComparer = atypeVersionComparer;
_btypeVersionComparer = btypeVersionComparer;
_syncStateFactory = syncStateFactory;
_synchronizationInterceptorFactory = synchronizationInterceptorFactory ?? NullSynchronizationInterceptorFactory <TAtypeEntityId, TAtypeEntityVersion, TAtypeEntity, TBtypeEntityId, TBtypeEntityVersion, TBtypeEntity, TContext> .Instance;
_atypeWriteRepository = atypeWriteRepository;
_btypeWriteRepository = btypeWriteRepository;
_atypeRepository = atypeRepository;
_btypeRepository = btypeRepository;
_entityRelationDataAccess = entityRelationDataAccess;
_entityRelationDataFactory = entityRelationDataFactory;
_initialEntityMatcher = initialEntityMatcher;
}
public TestableV2Feed(
IReadOnlyEntityRepository <Package> repo,
IGalleryConfigurationService configuration,
ISearchService searchService)
: base(repo, Mock.Of <IEntityRepository <Package> >(), configuration, GetNotNullISearchService(searchService), Mock.Of <ITelemetryService>(), GetFeatureFlagService())
{
}
public Synchronizer(
IReadOnlyEntityRepository <TAtypeEntity, TAtypeEntityId, TAtypeEntityVersion, TContext> atypeRepository,
IReadOnlyEntityRepository <TBtypeEntity, TBtypeEntityId, TBtypeEntityVersion, TContext> btypeRepository,
IBatchWriteOnlyEntityRepository <TAtypeEntity, TAtypeEntityId, TAtypeEntityVersion, TContext> atypeWriteRepository,
IBatchWriteOnlyEntityRepository <TBtypeEntity, TBtypeEntityId, TBtypeEntityVersion, TContext> btypeWriteRepository,
IInitialSyncStateCreationStrategy <TAtypeEntityId, TAtypeEntityVersion, TAtypeEntity, TBtypeEntityId, TBtypeEntityVersion, TBtypeEntity> initialSyncStateCreationStrategy,
IEntityRelationDataAccess <TAtypeEntityId, TAtypeEntityVersion, TBtypeEntityId, TBtypeEntityVersion> entityRelationDataAccess,
IEntityRelationDataFactory <TAtypeEntityId, TAtypeEntityVersion, TBtypeEntityId, TBtypeEntityVersion> entityRelationDataFactory,
IInitialEntityMatcher <TAtypeEntity, TAtypeEntityId, TAtypeEntityVersion, TBtypeEntity, TBtypeEntityId, TBtypeEntityVersion> initialEntityMatcher,
IEqualityComparer <TAtypeEntityId> atypeIdComparer, IEqualityComparer <TBtypeEntityId> btypeIdComparer,
ITotalProgressFactory totalProgressFactory,
IExceptionLogger exceptionLogger,
ISynchronizationContextFactory <TContext> contextFactory,
IEqualityComparer <TAtypeEntityVersion> atypeVersionComparer,
IEqualityComparer <TBtypeEntityVersion> btypeVersionComparer)
{
_initialSyncStateCreationStrategy = initialSyncStateCreationStrategy;
_totalProgressFactory = totalProgressFactory;
_atypeIdComparer = atypeIdComparer;
_btypeIdComparer = btypeIdComparer;
_exceptionLogger = exceptionLogger;
_contextFactory = contextFactory;
_atypeVersionComparer = atypeVersionComparer;
_btypeVersionComparer = btypeVersionComparer;
_atypeWriteRepository = atypeWriteRepository;
_btypeWriteRepository = btypeWriteRepository;
_atypeRepository = atypeRepository;
_btypeRepository = btypeRepository;
_entityRelationDataAccess = entityRelationDataAccess;
_entityRelationDataFactory = entityRelationDataFactory;
_initialEntityMatcher = initialEntityMatcher;
}
protected abstract TController CreateController(
IReadOnlyEntityRepository <Package> packagesRepository,
IEntityRepository <Package> readWritePackagesRepository,
IGalleryConfigurationService configurationService,
ISearchService searchService,
ITelemetryService telemetryService,
IFeatureFlagService featureFlagService);
public OnUserChangedHandler(IServiceRegistry serviceRegistry)
: base(serviceRegistry)
{
userRepository = serviceRegistry.GetService <RepositoryManager>().GetRepository <User>();
userRepository.EntityAdded += OnUserAdded;
userRepository.EntityUpdated += OnUserUpdated;
}
public void UserGetsSetToDisconnectedInUserRepository()
{
HandleMessage(clientDisconnection);
IReadOnlyEntityRepository <User> userRepository = ServiceRegistry.GetService <RepositoryManager>().GetRepository <User>();
User defaultUser = userRepository.FindEntityById(DefaultUser.Id);
Assert.IsTrue(defaultUser.ConnectionStatus.UserConnectionStatus.Equals(ConnectionStatus.Status.Disconnected));
}
public EntityContainer(IReadOnlyEntityRepository <TEntityId, TEntityVersion, TEntity, TContext> repository, IEqualityComparer <TEntityId> idComparer, int?maximumCacheSize, IChunkedExecutor chunkedExecutor)
{
_idComparer = idComparer;
_repository = repository;
_maximumCacheSize = maximumCacheSize;
_chunkedExecutor = chunkedExecutor;
_cachedEntities = new Dictionary <TEntityId, TEntity>(idComparer);
}
public OnParticipationChangedHandler(IServiceRegistry serviceRegistry)
: base(serviceRegistry)
{
participationRepository = (ParticipationRepository)RepositoryManager.GetRepository <Participation>();
conversationRepository = RepositoryManager.GetRepository <Conversation>();
participationRepository.EntityAdded += OnParticipationAdded;
participationRepository.EntityUpdated += OnParticipationChanged;
}
/// <summary>
/// ReadOnlyEntityController constructor
/// </summary>
/// <param name="repository"></param>
/// <param name="userManager"></param>
/// <param name="httpContextAccessor"></param>
/// <param name="membershipManager"></param>
/// <param name="configuration"></param>
protected ReadOnlyEntityController(IReadOnlyEntityRepository <T> repository,
ApplicationIdentityUserManager userManager,
IHttpContextAccessor httpContextAccessor,
IMembershipManager membershipManager,
IConfiguration configuration) : base(httpContextAccessor, userManager, membershipManager)
{
readRepository = repository;
config = configuration;
readRepository.SetContext(SecurityContext);
}
protected override void HandleMessage(EntitySnapshotRequest <User> message)
{
IReadOnlyEntityRepository <User> userRepository = ServiceRegistry.GetService <RepositoryManager>().GetRepository <User>();
var clientManager = ServiceRegistry.GetService <IClientManager>();
IEnumerable <User> currentUsers = userRepository.GetAllEntities();
var userSnapshot = new EntitySnapshot <User>(currentUsers);
clientManager.SendMessageToClient(userSnapshot, message.UserId);
}
public ConversationViewModel(Conversation conversation, IServiceRegistry serviceRegistry)
: base(serviceRegistry)
{
if (!IsInDesignMode)
{
this.conversation = conversation;
var repositoryManager = serviceRegistry.GetService <RepositoryManager>();
userRepository = repositoryManager.GetRepository <User>();
participationRepository = (ParticipationRepository)repositoryManager.GetRepository <Participation>();
}
}
public TestableV2Feed(
IReadOnlyEntityRepository <Package> repo,
IGalleryConfigurationService configuration,
ISearchService searchService)
: this(
repo,
configuration,
searchService,
Mock.Of <ITelemetryService>())
{
}
public ActiveConversationsViewModel(IServiceRegistry serviceRegistry)
: base(serviceRegistry)
{
if (!IsInDesignMode)
{
conversationRepository = ServiceRegistry.GetService <RepositoryManager>().GetRepository <Conversation>();
UpdateActiveConversations();
conversationRepository.EntityAdded += OnConversationChanged;
conversationRepository.EntityUpdated += OnConversationChanged;
}
}
public TestableV2Feed(
IReadOnlyEntityRepository <Package> repo,
IGalleryConfigurationService configuration,
ISearchService searchService,
ITelemetryService telemetryService)
: this(
repo,
configuration,
searchService,
telemetryService,
GetFeatureFlagService())
{
}
protected override void HandleMessage(EntitySnapshotRequest <Conversation> message)
{
var participationRepository = (ParticipationRepository)ServiceRegistry.GetService <RepositoryManager>().GetRepository <Participation>();
IReadOnlyEntityRepository <Conversation> conversationRepository = ServiceRegistry.GetService <RepositoryManager>().GetRepository <Conversation>();
var clientManager = ServiceRegistry.GetService <IClientManager>();
IEnumerable <int> conversationIds = participationRepository.GetAllConversationIdsByUserId(message.UserId);
List <Conversation> conversations = conversationIds.Select(conversationRepository.FindEntityById).ToList();
var conversationSnapshot = new EntitySnapshot <Conversation>(conversations);
clientManager.SendMessageToClient(conversationSnapshot, message.UserId);
}
public VCardTypeDetector(IReadOnlyEntityRepository <WebResourceName, string, vCard, ICardDavRepositoryLogger> cardDavRepository, IVCardTypeCache vcardTypeCache)
{
if (cardDavRepository == null)
{
throw new ArgumentNullException(nameof(cardDavRepository));
}
if (vcardTypeCache == null)
{
throw new ArgumentNullException(nameof(vcardTypeCache));
}
_cardDavRepository = cardDavRepository;
_vcardTypeCache = vcardTypeCache;
}
protected ODataFeedControllerFactsBase()
{
// Arrange
AllPackages = CreatePackagesQueryable();
AvailablePackages = AllPackages.Where(p => p.PackageStatusKey == PackageStatus.Available).ToList();
UnavailablePackages = AllPackages.Where(p => p.PackageStatusKey != PackageStatus.Available).ToList();
NonSemVer2Packages = AvailablePackages.Where(p => p.SemVerLevelKey == SemVerLevelKey.Unknown).ToList();
SemVer2Packages = AvailablePackages.Where(p => p.SemVerLevelKey == SemVerLevelKey.SemVer2).ToList();
var packagesRepositoryMock = new Mock <IReadOnlyEntityRepository <Package> >(MockBehavior.Strict);
packagesRepositoryMock.Setup(m => m.GetAll()).Returns(AllPackages).Verifiable();
PackagesRepository = packagesRepositoryMock.Object;
}
public ODataV1FeedController(
IReadOnlyEntityRepository <Package> packagesRepository,
IEntityRepository <Package> readWritePackagesRepository,
IGalleryConfigurationService configurationService,
IHijackSearchServiceFactory searchServiceFactory,
ITelemetryService telemetryService,
IFeatureFlagService featureFlagService)
: base(configurationService, telemetryService)
{
_packagesRepository = packagesRepository ?? throw new ArgumentNullException(nameof(packagesRepository));
_readWritePackagesRepository = readWritePackagesRepository ?? throw new ArgumentNullException(nameof(readWritePackagesRepository));
_configurationService = configurationService ?? throw new ArgumentNullException(nameof(configurationService));
_searchServiceFactory = searchServiceFactory ?? throw new ArgumentNullException(nameof(searchServiceFactory));
_featureFlagService = featureFlagService ?? throw new ArgumentNullException(nameof(featureFlagService));
}
public TestableV2Feed(
IReadOnlyEntityRepository <Package> repo,
IGalleryConfigurationService configuration,
ISearchService searchService,
ITelemetryService telemetryService,
IFeatureFlagService featureFlagService)
: base(
repo,
Mock.Of <IEntityRepository <Package> >(),
configuration,
GetSearchServiceFactory(searchService),
telemetryService,
featureFlagService)
{
}
protected override ODataV2FeedController CreateController(
IReadOnlyEntityRepository <Package> packagesRepository,
IEntityRepository <Package> readWritePackagesRepository,
IGalleryConfigurationService configurationService,
ISearchService searchService,
ITelemetryService telemetryService,
IFeatureFlagService featureFlagService)
{
return(new ODataV2FeedController(
packagesRepository,
readWritePackagesRepository,
configurationService,
searchService,
telemetryService,
featureFlagService));
}
public void ReturnsCorrectRepository()
{
IEntityRepository userRepository = new UserRepository();
IEntityRepository conversationRepository = new ConversationRepository();
IEntityRepository participationRepository = new ParticipationRepository();
var repositoryManager = new RepositoryManager();
repositoryManager.AddRepository <User>(userRepository);
repositoryManager.AddRepository <Conversation>(conversationRepository);
repositoryManager.AddRepository <Participation>(participationRepository);
IReadOnlyEntityRepository <Conversation> retrievedConversationRepository = repositoryManager.GetRepository <Conversation>();
Assert.AreEqual(conversationRepository, retrievedConversationRepository);
}
public MainWindowViewModel(IServiceRegistry serviceRegistry)
: base(serviceRegistry)
{
if (!IsInDesignMode)
{
userRepository = ServiceRegistry.GetService <RepositoryManager>().GetRepository <User>();
userId = ServiceRegistry.GetService <IClientService>().ClientUserId;
User user = userRepository.FindEntityById(userId);
if (user.Avatar.UserAvatar != null)
{
UserAvatar = user.Avatar.UserAvatar;
}
userRepository.EntityUpdated += OnUserUpdated;
}
}
protected override ODataV2CuratedFeedController CreateController(
IReadOnlyEntityRepository <Package> packagesRepository,
IEntityRepository <Package> readWritePackagesRepository,
IGalleryConfigurationService configurationService,
ISearchService searchService,
ITelemetryService telemetryService,
IFeatureFlagService featureFlagService)
{
configurationService.Current.RedirectedCuratedFeeds = new[] { _curatedFeedName };
return(new ODataV2CuratedFeedController(
configurationService,
searchService,
packagesRepository,
readWritePackagesRepository,
telemetryService,
featureFlagService));
}
public UserListViewModel(IServiceRegistry serviceRegistry)
: base(serviceRegistry)
{
if (!IsInDesignMode)
{
userRepository = serviceRegistry.GetService <RepositoryManager>().GetRepository <User>();
conversationRepository = serviceRegistry.GetService <RepositoryManager>().GetRepository <Conversation>();
participationRepository = (ParticipationRepository)serviceRegistry.GetService <RepositoryManager>().GetRepository <Participation>();
clientService = serviceRegistry.GetService <IClientService>();
userRepository.EntityAdded += OnUserChanged;
userRepository.EntityUpdated += OnUserChanged;
conversationRepository.EntityAdded += OnConversationAdded;
conversationRepository.EntityUpdated += OnConversationUpdated;
UpdateConnectedUsers();
}
}
public ContactAndDistListSynchronizer(
IPartialSynchronizer <string, DateTime, WebResourceName, string, ICardDavRepositoryLogger> contactSynchronizer,
ISynchronizer <DistributionListSychronizationContext> distributionListSynchronizer,
EmailAddressCacheDataAccess emailAddressCacheDataAccess,
LoggingCardDavRepositoryDecorator cardDavDataAccess,
IEntityRelationDataAccess <string, DateTime, WebResourceName, string> contactEntityRelationDataAccess,
IReadOnlyEntityRepository <string, DateTime, ContactItemWrapper, ICardDavRepositoryLogger> outlookContactRepository,
NameSpace outlookSession)
{
if (contactSynchronizer == null)
{
throw new ArgumentNullException(nameof(contactSynchronizer));
}
if (distributionListSynchronizer == null)
{
throw new ArgumentNullException(nameof(distributionListSynchronizer));
}
if (cardDavDataAccess == null)
{
throw new ArgumentNullException(nameof(cardDavDataAccess));
}
if (contactEntityRelationDataAccess == null)
{
throw new ArgumentNullException(nameof(contactEntityRelationDataAccess));
}
if (outlookContactRepository == null)
{
throw new ArgumentNullException(nameof(outlookContactRepository));
}
if (outlookSession == null)
{
throw new ArgumentNullException(nameof(outlookSession));
}
_contactSynchronizer = contactSynchronizer;
_distributionListSynchronizer = distributionListSynchronizer;
_emailAddressCacheDataAccess = emailAddressCacheDataAccess;
_cardDavDataAccess = cardDavDataAccess;
_contactEntityRelationDataAccess = contactEntityRelationDataAccess;
_outlookContactRepository = outlookContactRepository;
_outlookSession = outlookSession;
}
protected override ODataV1FeedController CreateController(
IReadOnlyEntityRepository <Package> packagesRepository,
IEntityRepository <Package> readWritePackagesRepository,
IGalleryConfigurationService configurationService,
ISearchService searchService,
ITelemetryService telemetryService,
IFeatureFlagService featureFlagService)
{
var searchServiceFactory = new Mock <IHijackSearchServiceFactory>();
searchServiceFactory
.Setup(f => f.GetService())
.Returns(searchService);
return(new ODataV1FeedController(
packagesRepository,
readWritePackagesRepository,
configurationService,
searchServiceFactory.Object,
telemetryService,
featureFlagService));
}
private void PopulateClientManager()
{
IReadOnlyEntityRepository <User> userRepository = ServiceRegistry.GetService <RepositoryManager>().GetRepository <User>();
var clientManager = new ClientManager();
foreach (User user in userRepository.GetAllEntities())
{
if (user.Id == DefaultUser.Id)
{
ConnectedUserClientHandler = new MockClientHandler();
clientManager.AddClientHandler(user.Id, ConnectedUserClientHandler);
}
else
{
clientManager.AddClientHandler(user.Id, new MockClientHandler());
}
}
ServiceRegistry.RegisterService <IClientManager>(clientManager);
}
public AutocompleteDatabasePackageIdsQuery(IReadOnlyEntityRepository <Package> packageRepository)
{
_packageRepository = packageRepository ?? throw new ArgumentNullException(nameof(packageRepository));
}
