public MessageItemTextViewModel(string text
     , ILanguageRepository languageRepository
     , ILogger logger) 
     : base(languageRepository, logger)
 {
     Text = text;
 }
        public FriendInfoViewModel(int friendId
            , ILanguageRepository languageRepository
            , IFriendsRepository friendsRepository
            , IFriendsAvatarsRepository friendsAvatarsRepository
            , ILogger logger) 
            : base(languageRepository, logger)
        {
            FriendId = friendId;

            if (friendsRepository.NotEmpty())
            {
                var friend = friendsRepository.Data.FirstOrDefault(x => x.VkId == friendId);

                if (friend != null)
                {
                    FullName = friend.FullName;
                    Online = friend.Online;
                }
            }

            if (friendsAvatarsRepository.NotEmpty())
            {
                var content = friendsAvatarsRepository.Data.FirstOrDefault(x => x.FriendId == friendId)?.Content;
                Avatar = CreateBitmapImage(content);
            }
        }
Example #3
0
        public ScoreController(IBaseScoreCardRepository baseScoreCardRepository, IBaseJournalPriceRepository baseJournalPriceRepository, IValuationScoreCardRepository valuationScoreCardRepository, IValuationJournalPriceRepository valuationJournalPriceRepository, IScoreCardVersionRepository scoreCardVersionRepository, IJournalRepository journalRepository, ILanguageRepository languageRepository, ISubjectRepository subjectRepository, IQuestionRepository questionRepository, GeneralSettings generalSettings, IUserProfileRepository userProfileRepository, IInstitutionRepository institutionRepository, IAuthentication authentication)
            : base(userProfileRepository, authentication)
        {
            Requires.NotNull(baseScoreCardRepository, "baseScoreCardRepository");
            Requires.NotNull(baseJournalPriceRepository, "baseJournalPriceRepository");
            Requires.NotNull(valuationScoreCardRepository, "valuationScoreCardRepository");
            Requires.NotNull(valuationJournalPriceRepository, "valuationJournalPriceRepository");
            Requires.NotNull(scoreCardVersionRepository, "scoreCardVersionRepository");
            Requires.NotNull(journalRepository, "journalRepository");
            Requires.NotNull(languageRepository, "languageRepository");
            Requires.NotNull(subjectRepository, "keywordRepository");
            Requires.NotNull(questionRepository, "questionRepository");
            Requires.NotNull(institutionRepository, "institutionRepository");
            Requires.NotNull(generalSettings, "generalSettings");

            this.baseScoreCardRepository = baseScoreCardRepository;
            this.scoreCardVersionRepository = scoreCardVersionRepository;
            this.valuationJournalPriceRepository = valuationJournalPriceRepository;
            this.valuationScoreCardRepository = valuationScoreCardRepository;
            this.journalRepository = journalRepository;
            this.languageRepository = languageRepository;
            this.subjectRepository = subjectRepository;
            this.questionRepository = questionRepository;
            this.baseJournalPriceRepository = baseJournalPriceRepository;
            this.institutionRepository = institutionRepository;
            this.generalSettings = generalSettings;
        }
 public MessageController(IMessageRepository messageRepository, ILanguageRepository languageRepository,
     IDayRepository dayRepository)
 {
     _messageRepository = messageRepository;
     _languageRepository = languageRepository;
     _dayRepository = dayRepository;
 }
		/// <summary>
		/// Local Test Service constructor
		/// </summary>
		/// <param name="testFileLocker">the testFileLocker</param>
		/// <param name="testsystemRepository">the testSystemRepository</param>
		/// <param name="languageRepository">the languageRepository</param>
		/// <param name="browserRepository">the browserRepository</param>
		/// <param name="testerRepository">the testerRepository</param>
		/// <param name="testsuiteRepository">the testsuiteRepository</param>
		/// <param name="testcaseRepository">the testcaseRepository</param>
		/// <param name="testPool">the testPool</param>
		public LocalTestService(ITestFileLocker testFileLocker, ITestsystemRepository testsystemRepository,
			ILanguageRepository languageRepository, IBrowserRepository browserRepository, ITesterRepository testerRepository,
			ITestsuiteRepository testsuiteRepository, ITestcaseRepository testcaseRepository, ITestPool testPool)
		{
			if (testFileLocker == null)
				throw new ArgumentNullException("testFileLocker");
			if (testsystemRepository == null)
				throw new ArgumentNullException("testsystemRepository");
			if (languageRepository == null)
				throw new ArgumentNullException("languageRepository");
			if (browserRepository == null)
				throw new ArgumentNullException("browserRepository");
			if (testerRepository == null)
				throw new ArgumentNullException("testerRepository");
			if (testsuiteRepository == null)
				throw new ArgumentNullException("testsuiteRepository");
			if (testcaseRepository == null)
				throw new ArgumentNullException("testcaseRepository");
			if (testPool == null)
				throw new ArgumentNullException("testPool");

			_testFileLocker = testFileLocker;
			_testsystemRepository = testsystemRepository;
			_languageRepository = languageRepository;
			_browserRepository = browserRepository;
			_testerRepository = testerRepository;
			_testsuiteRepository = testsuiteRepository;
			_testcaseRepository = testcaseRepository;
			_testPool = testPool;
		}
Example #6
0
        public void Initialize()
        {
            _languages = new List<LanguageData>
            {
                new LanguageData {IsDefault = true, LanguageId = 1, Name = "ua"},
                new LanguageData {IsDefault = false, LanguageId = 2, Name = "ru"},
                new LanguageData {IsDefault = false, LanguageId = 3, Name = "en"}
            };

            _mock.Setup(m => m.GetDefaultLanguageName()).Returns("en");
            _mock.Setup(m => m.GetLanguageByKey("en"))
                .Returns(new Language {Name = "en", IsDefault = false, LanguageId = 3});
            _mock.Setup(m => m.GetLanguageByKey("ru"))
                .Returns(new Language {Name = "ru", IsDefault = false, LanguageId = 2});
            _mock.Setup(m => m.GetLanguageByKey("uk"))
                .Returns(new Language {Name = "uk", IsDefault = true, LanguageId = 1});

            _mock.Setup(m => m.GetLanguageByKey(""))
                .Returns(new Language {Name = "uk", IsDefault = true, LanguageId = 1});
            _mock.Setup(m => m.GetLanguageByKey(null))
                .Returns(new Language {Name = "uk", IsDefault = true, LanguageId = 1});
            _mock.Setup(m => m.GetLanguageByKey("Cz"))
                .Returns(new Language {Name = "uk", IsDefault = true, LanguageId = 1});
            _mock.Setup(m => m.GetAllLanguagesData()).Returns(_languages);

            _mockLanguageRepository = _mock.Object;
        }
        public MessageListViewModel(int friendId
            , IMessageItemModelFactory messageItemModelFactory
            , IUserInfoRepository userInfoRepository
            , IFriendsRepository friendsRepository
            , IDialogMessagesRepository dialogMessagesRepository
            , ILoadingIndicatorViewModel loadingIndicatorModel
            , ILanguageRepository languageRepository
            , ILogger logger) 
            : base(languageRepository, logger)
        {
            _messageItemModelFactory = messageItemModelFactory;
            FriendId = friendId;
            MessageViews = new BindableCollection<IMessageBaseItemViewModel>();
            LoadingIndicatorModel = loadingIndicatorModel;

            if (userInfoRepository.NotEmpty())
            {
                UserFirstName = userInfoRepository.Data.FirstName;
            }

            if (friendsRepository.NotEmpty())
            {
                FriendFirstName = friendsRepository.Data.FirstOrDefault(x => x.VkId == friendId)?.FirstName;
            }

            dialogMessagesRepository.AddingRange += DialogMessagesAddingRange;
            dialogMessagesRepository.AddedRange += DialogMessagesAddedRange;
            dialogMessagesRepository.AddRangeFailed += DialogMessagesAddRangeFailed;
        }
Example #8
0
 public MasterController(IApplicationRepository appRepository, ITweetRepository tweetRepository,
     ITweeterRepository tweeterRepository, ILanguageRepository languageRepository)
 {
     this.AppRepository = appRepository;
     this.TweetRepository = tweetRepository;
     this.TweeterRepository = tweeterRepository;
     this.LanguageRepository = languageRepository;
 }
 public LoadLanguageRepository(ILanguageRepository languageRepository
     , ILoadLanguageFactory loadLanguageFactory
     , IAppConfig appConfig)
 {
     _languageRepository = languageRepository;
     _loadLanguageFactory = loadLanguageFactory;
     _appConfig = appConfig;
 }
Example #10
0
 public MenuItemViewModel(IMenuItem menuItem
     , ILanguageRepository languageRepository
     , ILogger logger
     , IEventAggregator eventAggregator) 
     : base(languageRepository, logger, eventAggregator)
 {
     _menuItem = menuItem;
 }
Example #11
0
 public StartBackgroundTasks(IApplicationRepository applicationRepository, ITweetRepository tweetRepository,
     ITweeterRepository tweeterRepository, ILanguageRepository languageRepository)
 {
     this.ApplicationRepository = applicationRepository;
     this.TweetRepository = tweetRepository;
     this.TweeterRepository = tweeterRepository;
     this.LanguageRepository = languageRepository;
 }
Example #12
0
 public VkAuthorizer(IAppConfig appConfig
     , ILanguageRepository languageRepository
     , VkApiClient apiClient
     , IOAuthAuthorizer oAuthAuthorizer)
 {
     _appConfig = appConfig;
     _languageRepository = languageRepository;
     _apiClient = apiClient;
     _oAuthAuthorizer = oAuthAuthorizer;
 }
          public RoomReservationsController(IRoomReservationsRepository RoomReservationRepository, IClubsRepository ClubRepository,IReservation_SourcesRepository  Reservation_SourceRepository, ICountryRepository  CountryRepository,
          ITitlesRepository  TitleRepository,
          ILanguageRepository  LanguageRepository,
          IRoomAllocationsRepository  RoomAllocationRepository,
          IRoomTypesRepository  RoomTypeRepository,
          IFacilitiesRepository  FacilityRepository  ,
          IRoomReservation_FacilitiesRepository RoomReservation_FacilitiesRepository,
          IReservationStatusTypeRepository ReservationStatusTypeRepository,
          IReason_TypesRepository Reason_TypeRepository,
          IPaymentByRepository    PaymentByRepository,
          IPaymentModeRepository   PaymentModeRepository,
          IBillTimeRepository      BillTimeRepository,
          ICurrencyRepository  CurrencyRepository,
          IMembersRepository  MemberRepository,
          IGuestsRepository GuestRepository,
              IRoomReservation_RoomDetailsRepository  RoomReservation_RoomDetailsRepository,
              IRoomReservation_PaymentsRepository RoomReservation_PaymentRepository,
              IRoomReservation_StatusRepository  RoomReservation_StatusRepository,
              IRoomStatus_DetailsRepository  RoomStatus_DetailRepository,
              IWingsRepository WingRepository,
              IDocument_TypeRepository Document_TypeRepository,
              IGuest_DocumentsRepository Guest_DocumentsRepository,
              IReason_TypesRepository Reason_TypesRepository
              )
        {
            _RoomReservationRepository = RoomReservationRepository;
            _Reservation_SourceRepository = Reservation_SourceRepository;
            _ClubRepository = ClubRepository;
            _CountryRepository =  CountryRepository;
            _TitleRepository = TitleRepository;
            _LanguageRepository =LanguageRepository;
            _RoomAllocationRepository = RoomAllocationRepository;
            _RoomTypeRepository = RoomTypeRepository;
            _FacilityRepository = FacilityRepository;
            _RoomReservation_FacilitiesRepository = RoomReservation_FacilitiesRepository;
            _ReservationStatusTypeRepository = ReservationStatusTypeRepository;
            _Reason_TypeRepository = Reason_TypeRepository;
            _PaymentByRepository = PaymentByRepository;
            _PaymentModeRepository = PaymentModeRepository;
            _BillTimeRepository = BillTimeRepository;
            _CurrencyRepository =  CurrencyRepository;
            _MemberRepository = MemberRepository;
            _GuestRepository = GuestRepository;
            _RoomReservation_RoomDetailsRepository = RoomReservation_RoomDetailsRepository;
            _RoomReservation_PaymentRepository = RoomReservation_PaymentRepository;
            _RoomReservation_StatusRepository =RoomReservation_StatusRepository;
            _RoomStatus_DetailRepository = RoomStatus_DetailRepository;
            _WingRepository = WingRepository;

            _Document_TypeRepository = Document_TypeRepository;
            _Guest_DocumentsRepository = Guest_DocumentsRepository;
            _Reason_TypesRepository =  Reason_TypesRepository;

        }
Example #14
0
 public AdminController(IRestarauntRepository restRepository, IRestarauntLangRepository restLangRepository,
                         ICommentRepository commentRepository, IImageRepository imageRepository, IUserRepository userRepository,
                         ILanguageRepository langRepository, IWorkWithDBProvider workWithDBProvider)
 {
     this.restRepository = restRepository;
     this.restLangRepository = restLangRepository;
     this.commentRepository = commentRepository;
     this.imageRepository = imageRepository;
     this.userRepository = userRepository;
     this.langRepository = langRepository;
     this.workWithDBProvider = workWithDBProvider;
 }
 public MessageInputViewModel(int friendId
     , ISendMessageToVk sendMessageToVk
     , ISessionInfoRepository sessionInfoRepository
     , ILoadingIndicatorViewModel loadingIndicatorModel
     , ILanguageRepository languageRepository
     , ILogger logger) 
     : base(languageRepository, logger)
 {
     _sendMessageToVk = sendMessageToVk;
     _sessionInfoRepository = sessionInfoRepository;
     FriendId = friendId;
     LoadingIndicatorModel = loadingIndicatorModel;
 }
Example #16
0
        public JournalsImport(IJournalRepository journalRepository, ILanguageRepository languageRepository, ICountryRepository countryRepository, ISubjectRepository subjectRepository, IPublisherRepository publisherRepository, GeneralImportSettings importSettings)
        {
            Requires.NotNull(journalRepository, "journalRepository");
            Requires.NotNull(languageRepository, "languageRepository");
            Requires.NotNull(countryRepository, "countryRepository");
            Requires.NotNull(subjectRepository, "subjectRepository");
            Requires.NotNull(publisherRepository, "publisherRepository");
            Requires.NotNull(importSettings, "importSettings");

            this.journalRepository = journalRepository;
            this.languageRepository = languageRepository;
            this.countryRepository = countryRepository;
            this.subjectRepository = subjectRepository;
            this.publisherRepository = publisherRepository;
            this.importSettings = importSettings;
        }
        public MessageItemViewModel(IDialogMessage dialogMessage
            , string firstName
            , IMessageItemBodyModelFactory messageItemBodyModelFactory
            , ILanguageRepository languageRepository
            , ILogger logger) 
            : base(languageRepository, logger)
        {
            _dialogMessage = dialogMessage;
            _messageItemBodyModelFactory = messageItemBodyModelFactory;

            FirstName = firstName;
            NameColor = dialogMessage.Out
                ? FindResource<SolidColorBrush>("MessageSelfNameColor")
                : FindResource<SolidColorBrush>("MessageFriendNameColor");
            DateLabel = DateTime.Today == Date.Date ? Date.ToTimeString() : Date.ToDateString();
            Body = GenerateBody(dialogMessage.Body);
            ReadState = dialogMessage.ReadState;
        }
Example #18
0
        public JournalsController(IJournalRepository journalRepository, IBaseJournalPriceRepository baseJournalPriceRepository, IValuationJournalPriceRepository valuationJournalPriceRepository,
            IValuationScoreCardRepository valuationScoreCardRepository, ILanguageRepository languageRepository,
            IInstitutionJournalRepository institutionJournalRepository, IBaseScoreCardRepository baseScoreCardRepository, IUserProfileRepository userProfileRepository, IAuthentication authentication,
            IInstitutionRepository institutionRepository, IBulkImporter<UniversityLicense> bulkImporter)
            : base(baseScoreCardRepository, valuationScoreCardRepository, userProfileRepository, authentication)
        {
            Requires.NotNull(journalRepository, nameof(journalRepository));
            Requires.NotNull(baseJournalPriceRepository, nameof(baseJournalPriceRepository));
            Requires.NotNull(valuationJournalPriceRepository, nameof(valuationJournalPriceRepository));
            Requires.NotNull(languageRepository, nameof(languageRepository));
            Requires.NotNull(institutionJournalRepository, nameof(institutionJournalRepository));
            Requires.NotNull(institutionRepository, nameof(institutionRepository));
            Requires.NotNull(valuationJournalPriceRepository, nameof(valuationJournalPriceRepository));
            Requires.NotNull(bulkImporter, nameof(bulkImporter));

            this.journalRepository = journalRepository;
            this.baseJournalPriceRepository = baseJournalPriceRepository;
            this.institutionJournalRepository = institutionJournalRepository;
            this.institutionRepository = institutionRepository;
            this.valuationJournalPriceRepository = valuationJournalPriceRepository;
            _bulkImporter = bulkImporter;
        }
		/// <summary>
		/// Create a new SettingsService
		/// </summary>
		/// <param name="browserRepository">the BrowserRepository</param>
		/// <param name="languageRepository">the LanguageRepository</param>
		/// <param name="testerRepository">the TesterRepository</param>
		/// <param name="testsystemRepository">the TestsystemRepository</param>
		/// <param name="testcaseRepository">the TestcaseRepository</param>
		/// <param name="testsuiteRepository">the TestsuiteRepository</param>
		public SettingsService(IBrowserRepository browserRepository, ILanguageRepository languageRepository, 
			ITesterRepository testerRepository, ITestsystemRepository testsystemRepository, ITestcaseRepository testcaseRepository, ITestsuiteRepository testsuiteRepository)
		{
			if (browserRepository == null)
				throw new ArgumentNullException("browserRepository");
			if (languageRepository == null)
				throw new ArgumentNullException("languageRepository");
			if (testerRepository == null)
				throw new ArgumentNullException("testerRepository");
			if (testsystemRepository == null)
				throw new ArgumentNullException("testsystemRepository");
			if (testcaseRepository == null)
				throw new ArgumentNullException("testcaseRepository");
			if (testsuiteRepository == null)
				throw new ArgumentNullException("testsuiteRepository");

			_browserRepository = browserRepository;
			_languageRepository = languageRepository;
			_testerRepository = testerRepository;
			_testsystemRepository = testsystemRepository;
			_testcaseRepository = testcaseRepository;
			_testsuiteRepository = testsuiteRepository;
		}
        public FriendListViewModel(bool displayOnlineStatuses
            , IFriendsRepository friendsRepository
            , IFriendsAvatarsRepository friendsAvatarsRepository
            , IFriendItemModelFactory friendItemViewModelFactory
            , ILoadingIndicatorViewModel loadingIndicatorViewModel
            , ILanguageRepository languageRepository
            , ILogger logger)
            : base(languageRepository, logger)
        {
            _friendItemViewModelFactory = friendItemViewModelFactory;
            _friendsAvatarsRepository = friendsAvatarsRepository;

            _displayOnlineStatuses = displayOnlineStatuses;

            FriendViews = new BindableCollection<IFriendItemViewModel>();
            LoadingIndicatorModel = loadingIndicatorViewModel;

            friendsAvatarsRepository.Adding += FriendsAvatarsRepositoryAdding;
            friendsAvatarsRepository.Added += FriendsAvatarsRepositoryAdded;
            friendsAvatarsRepository.AddFailed += FriendsAvatarsRepositoryAddFailed;

            BindLoadingIndicatorToCollectionRepository<IFriendsRepository, IFriend>(loadingIndicatorViewModel, friendsRepository);
        }
Example #21
0
        public JournalsController(IJournalRepository journalRepository, IBaseJournalPriceRepository baseJournalPriceRepository, IValuationJournalPriceRepository valuationJournalPriceRepository, IValuationScoreCardRepository valuationScoreCardRepository, ILanguageRepository languageRepository, ISubjectRepository subjectRepository, IInstitutionJournalRepository institutionJournalRepository, IBaseScoreCardRepository baseScoreCardRepository, IUserProfileRepository userProfileRepository, IAuthentication authentication, IInstitutionRepository institutionRepository)
            : base(userProfileRepository, authentication)
        {
            Requires.NotNull(journalRepository, "journalRepository");
            Requires.NotNull(baseJournalPriceRepository, "baseJournalPriceRepository");
            Requires.NotNull(valuationJournalPriceRepository, "valuationJournalPriceRepository");
            Requires.NotNull(valuationScoreCardRepository, "valuationScoreCardRepository");
            Requires.NotNull(languageRepository, "languageRepository");
            Requires.NotNull(subjectRepository, "keywordRepository");
            Requires.NotNull(institutionJournalRepository, "institutionJournalRepository");
            Requires.NotNull(baseScoreCardRepository, "scoreCardRepository");
            Requires.NotNull(institutionRepository, "institutionRepository");
            Requires.NotNull(valuationJournalPriceRepository, "valuationJournalPriceRepository");

            this.journalRepository = journalRepository;
            this.baseJournalPriceRepository = baseJournalPriceRepository;
            this.languageRepository = languageRepository;
            this.subjectRepository = subjectRepository;
            this.institutionJournalRepository = institutionJournalRepository;
            this.baseScoreCardRepository = baseScoreCardRepository;
            this.valuationScoreCardRepository = valuationScoreCardRepository;
            this.institutionRepository = institutionRepository;
            this.valuationJournalPriceRepository = valuationJournalPriceRepository;
        }
Example #22
0
        public ScoreController(IBaseScoreCardRepository baseScoreCardRepository, IBaseJournalPriceRepository baseJournalPriceRepository, IValuationScoreCardRepository valuationScoreCardRepository, IValuationJournalPriceRepository valuationJournalPriceRepository, IScoreCardVersionRepository scoreCardVersionRepository, IJournalRepository journalRepository, ILanguageRepository languageRepository, IQuestionRepository questionRepository, GeneralSettings generalSettings, IUserProfileRepository userProfileRepository, IInstitutionRepository institutionRepository, IAuthentication authentication, IBulkImporter<AuthorToInvite> bulkImporter, IUserJournalRepository userJournalRepository)
            : base(baseScoreCardRepository, valuationScoreCardRepository, userProfileRepository, authentication)
        {
            Requires.NotNull(baseJournalPriceRepository, nameof(baseJournalPriceRepository));
            Requires.NotNull(valuationJournalPriceRepository, nameof(valuationJournalPriceRepository));
            Requires.NotNull(scoreCardVersionRepository, nameof(scoreCardVersionRepository));
            Requires.NotNull(journalRepository, nameof(journalRepository));
            Requires.NotNull(languageRepository, nameof(languageRepository));
            Requires.NotNull(questionRepository, nameof(questionRepository));
            Requires.NotNull(institutionRepository, nameof(institutionRepository));
            Requires.NotNull(generalSettings, nameof(generalSettings));

            this.scoreCardVersionRepository = scoreCardVersionRepository;
            this.valuationJournalPriceRepository = valuationJournalPriceRepository;
            this.journalRepository = journalRepository;
            this.languageRepository = languageRepository;
            this.questionRepository = questionRepository;
            this.baseJournalPriceRepository = baseJournalPriceRepository;
            this.institutionRepository = institutionRepository;
            this.generalSettings = generalSettings;

            _bulkImporter = bulkImporter;
            _userJournalRepository = userJournalRepository;
        }
Example #23
0
 public LanguageService(IUnitOfWork unitOfWork, ILanguageRepository repository) : base(unitOfWork, repository)
 {
     _repository = repository;
 }
Example #24
0
 public VoteController(IApplicationRepository appRepository, ITweetRepository tweetRepository,
     ITweeterRepository tweeterRepository, ILanguageRepository languageRepository)
     : base(appRepository, tweetRepository, tweeterRepository, languageRepository)
 {
 }
Example #25
0
 public SnippetController(IGroupRepository grepo, ISnippetRepository snippetSnipRepo, ILanguageRepository languageRepo, IUserRepository uRepo)
 {
     _snipRepo  = snippetSnipRepo;
     _langRepo  = languageRepo;
     _userRepo  = uRepo;
     _groupRepo = grepo;
 }
Example #26
0
 public GetLanguageQueryHandler(ILanguageRepository languageRepository, IMediator mediator)
 {
     _languageRepository = languageRepository;
     _mediator           = mediator;
 }
Example #27
0
    public static IEnumerable <IProperty> BuildEntities(IPropertyType[]?propertyTypes, IReadOnlyCollection <PropertyDataDto> dtos, int publishedVersionId, ILanguageRepository languageRepository)
    {
        var properties = new List <IProperty>();
        var xdtos      = dtos.GroupBy(x => x.PropertyTypeId).ToDictionary(x => x.Key, x => (IEnumerable <PropertyDataDto>)x);

        if (propertyTypes is null)
        {
            return(properties);
        }

        foreach (IPropertyType propertyType in propertyTypes)
        {
            var values     = new List <Property.InitialPropertyValue>();
            int propertyId = default;

            // see notes in BuildDtos - we always have edit+published dtos
            if (xdtos.TryGetValue(propertyType.Id, out IEnumerable <PropertyDataDto>?propDtos))
            {
                foreach (PropertyDataDto propDto in propDtos)
                {
                    propertyId = propDto.Id;
                    values.Add(new Property.InitialPropertyValue(
                                   languageRepository.GetIsoCodeById(propDto.LanguageId),
                                   propDto.Segment,
                                   propDto.VersionId == publishedVersionId,
                                   propDto.Value));
                }
            }

            var property = Property.CreateWithValues(propertyId, propertyType, values.ToArray());
            properties.Add(property);
        }

        return(properties);
    }
Example #28
0
 public ReorderLanguagesHandler(ILanguageRepository languageRepository, ISiteRules siteRules)
 {
     _languageRepository = languageRepository;
     _siteRules          = siteRules;
 }
Example #29
0
 public UserServiceImpl()
 {
     userRepo     = Factory.GetInstance().GetUserRepo();
     languageRepo = Factory.GetInstance().GetLanguageRepo();
 }
Example #30
0
 public LanguageParser(ILanguageCompiler languageCompiler,
                       ILanguageRepository languageRepository)
 {
     this.languageCompiler = languageCompiler;
     this.languageRepository = languageRepository;
 }
Example #31
0
 public PasteController(IPasteRepository pasteRepository, ILanguageRepository languageRepository)
 {
     _pasteRepository    = pasteRepository;
     _languageRepository = languageRepository;
 }
 public TranslationController(IDbConnection connection, ILanguageRepository languageRepository) : base(connection, languageRepository)
 {
 }
 public LanguageController(ILanguageRepository LanguageRepository)
 {
     _LanguageRepository = LanguageRepository;
 
 }
Example #34
0
 public LanguageServices(ILanguageRepository Repository, IUnitOfWork unitOfWork)
 {
     this._Repository = Repository;
     this._unitOfWork = unitOfWork;
 }
 public LanguageApplication(ILanguageRepository languageRepository)
 {
     _LanguageRepository = languageRepository;
 }
 public UpdateLanguageDetailsHandler(ILanguageRepository languageRepository,
                                     IValidator <UpdateLanguageDetails> validator)
 {
     _languageRepository = languageRepository;
     _validator          = validator;
 }
 public DeleteLanguageCommandHandler(ILanguageRepository languageRepository, ILanguageQueries languageQueries)
 {
     this.languageRepository = languageRepository;
     this.languageQueries    = languageQueries;
 }
Example #38
0
 public ActivateLanguageHandler(ILanguageRepository languageRepository, IValidator <ActivateLanguage> validator)
 {
     _languageRepository = languageRepository;
     _validator          = validator;
 }
Example #39
0
 public MediaRepository(IScopeAccessor scopeAccessor, AppCaches cache, ILogger logger, IMediaTypeRepository mediaTypeRepository, ITagRepository tagRepository, ILanguageRepository languageRepository, IRelationRepository relationRepository, IRelationTypeRepository relationTypeRepository,
                        Lazy <PropertyEditorCollection> propertyEditorCollection, DataValueReferenceFactoryCollection dataValueReferenceFactories)
     : base(scopeAccessor, cache, logger, languageRepository, relationRepository, relationTypeRepository, propertyEditorCollection, dataValueReferenceFactories)
 {
     _cache = cache;
     _mediaTypeRepository       = mediaTypeRepository ?? throw new ArgumentNullException(nameof(mediaTypeRepository));
     _tagRepository             = tagRepository ?? throw new ArgumentNullException(nameof(tagRepository));
     _mediaByGuidReadRepository = new MediaByGuidReadRepository(this, scopeAccessor, cache, logger);
 }
Example #40
0
 public GetLab(IHttpContextAccessor httpContextAccessor, ILanguageRepository ILang)
 {
     _httpContextAccessor = httpContextAccessor;
     _session             = _httpContextAccessor.HttpContext.Session;
     _ILang = ILang;
 }
Example #41
0
 public CategoryService(RequestInfo info, IUnitOfWork unitOfWork,
                        IRepository <Category> repository, IProductRepository productRepository, IRepository <ProductPicture> pictureRepository, ILanguageRepository languageRepository) : base(unitOfWork, info)
 {
     ProductRepository  = productRepository;
     PictureRepository  = pictureRepository;
     LanguageRepository = languageRepository;
     Repository         = repository;
 }
Example #42
0
 public LanguageService(ILanguageRepository languageRepository)
 {
     _languageRepository = languageRepository;
 }
Example #43
0
 public CreateLanguageInternalCommandHandler(ILanguageRepository languageRepository, IMediator mediator)
 {
     _languageRepository = languageRepository;
     _mediator           = mediator;
 }
 public DeleteLanguageCommand(ILanguageRepository languageRepository) =>
Example #45
0
    /// <summary>
    ///     Creates a collection of <see cref="PropertyDataDto" /> from a collection of <see cref="Property" />
    /// </summary>
    /// <param name="contentVariation">
    ///     The <see cref="ContentVariation" /> of the entity containing the collection of <see cref="Property" />
    /// </param>
    /// <param name="currentVersionId"></param>
    /// <param name="publishedVersionId"></param>
    /// <param name="properties">The properties to map</param>
    /// <param name="languageRepository"></param>
    /// <param name="edited">out parameter indicating that one or more properties have been edited</param>
    /// <param name="editedCultures">
    ///     Out parameter containing a collection of edited cultures when the contentVariation varies by culture.
    ///     The value of this will be used to populate the edited cultures in the umbracoDocumentCultureVariation table.
    /// </param>
    /// <returns></returns>
    public static IEnumerable <PropertyDataDto> BuildDtos(
        ContentVariation contentVariation,
        int currentVersionId,
        int publishedVersionId,
        IEnumerable <IProperty> properties,
        ILanguageRepository languageRepository,
        out bool edited,
        out HashSet <string>?editedCultures)
    {
        var propertyDataDtos = new List <PropertyDataDto>();

        edited         = false;
        editedCultures = null;        // don't allocate unless necessary
        string?defaultCulture = null; // don't allocate unless necessary

        var entityVariesByCulture = contentVariation.VariesByCulture();

        // create dtos for each property values, but only for values that do actually exist
        // ie have a non-null value, everything else is just ignored and won't have a db row
        foreach (IProperty property in properties)
        {
            if (property.PropertyType.SupportsPublishing)
            {
                // create the resulting hashset if it's not created and the entity varies by culture
                if (entityVariesByCulture && editedCultures == null)
                {
                    editedCultures = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
                }

                // publishing = deal with edit and published values
                foreach (IPropertyValue propertyValue in property.Values)
                {
                    var isInvariantValue = propertyValue.Culture == null && propertyValue.Segment == null;
                    var isCultureValue   = propertyValue.Culture != null;
                    var isSegmentValue   = propertyValue.Segment != null;

                    // deal with published value
                    if ((propertyValue.PublishedValue != null || isSegmentValue) && publishedVersionId > 0)
                    {
                        propertyDataDtos.Add(BuildDto(publishedVersionId, property, languageRepository.GetIdByIsoCode(propertyValue.Culture), propertyValue.Segment, propertyValue.PublishedValue));
                    }

                    // deal with edit value
                    if (propertyValue.EditedValue != null || isSegmentValue)
                    {
                        propertyDataDtos.Add(BuildDto(currentVersionId, property, languageRepository.GetIdByIsoCode(propertyValue.Culture), propertyValue.Segment, propertyValue.EditedValue));
                    }

                    // property.Values will contain ALL of it's values, both variant and invariant which will be populated if the
                    // administrator has previously changed the property type to be variant vs invariant.
                    // We need to check for this scenario here because otherwise the editedCultures and edited flags
                    // will end up incorrectly set in the umbracoDocumentCultureVariation table so here we need to
                    // only process edited cultures based on the current value type and how the property varies.
                    // The above logic will still persist the currently saved property value for each culture in case the admin
                    // decides to swap the property's variance again, in which case the edited flag will be recalculated.
                    if ((property.PropertyType.VariesByCulture() && isInvariantValue) ||
                        (!property.PropertyType.VariesByCulture() && isCultureValue))
                    {
                        continue;
                    }

                    // use explicit equals here, else object comparison fails at comparing eg strings
                    var sameValues = propertyValue?.PublishedValue == null
                        ? propertyValue?.EditedValue == null
                        : propertyValue.PublishedValue.Equals(propertyValue.EditedValue);

                    edited |= !sameValues;

                    if (entityVariesByCulture && !sameValues)
                    {
                        if (isCultureValue && propertyValue?.Culture is not null)
                        {
                            editedCultures?.Add(propertyValue.Culture); // report culture as edited
                        }
                        else if (isInvariantValue)
                        {
                            // flag culture as edited if it contains an edited invariant property
                            if (defaultCulture == null)
                            {
                                defaultCulture = languageRepository.GetDefaultIsoCode();
                            }

                            editedCultures?.Add(defaultCulture);
                        }
                    }
                }
            }
            else
            {
                foreach (IPropertyValue propertyValue in property.Values)
                {
                    // not publishing = only deal with edit values
                    if (propertyValue.EditedValue != null)
                    {
                        propertyDataDtos.Add(BuildDto(currentVersionId, property, languageRepository.GetIdByIsoCode(propertyValue.Culture), propertyValue.Segment, propertyValue.EditedValue));
                    }
                }

                edited = true;
            }
        }

        return(propertyDataDtos);
    }
Example #46
0
 public DeleteLanguageHandler(ILanguageRepository languageRepository, IValidator <DeleteLanguage> validator)
 {
     _languageRepository = languageRepository;
     _validator          = validator;
 }
Example #47
0
 public LanguageService(ILanguageRepository repository)
     : base(repository)
 {
     _repository = repository;
 }
 public ContentTypeRepository(IScopeAccessor scopeAccessor, AppCaches cache, ILogger <ContentTypeRepository> logger, IContentTypeCommonRepository commonRepository, ILanguageRepository languageRepository, IShortStringHelper shortStringHelper)
     : base(scopeAccessor, cache, logger, commonRepository, languageRepository, shortStringHelper)
 {
 }
 public MediaRepository(IScopeAccessor scopeAccessor, CacheHelper cache, ILogger logger, IMediaTypeRepository mediaTypeRepository, ITagRepository tagRepository, IContentSection contentSection, ILanguageRepository languageRepository)
     : base(scopeAccessor, cache, languageRepository, logger)
 {
     _mediaTypeRepository       = mediaTypeRepository ?? throw new ArgumentNullException(nameof(mediaTypeRepository));
     _tagRepository             = tagRepository ?? throw new ArgumentNullException(nameof(tagRepository));
     _mediaByGuidReadRepository = new MediaByGuidReadRepository(this, scopeAccessor, cache, logger);
     EnsureUniqueNaming         = contentSection.EnsureUniqueNaming;
 }
 public MediaTypeRepository(IScopeAccessor scopeAccessor, AppCaches cache, ILogger logger, IContentTypeCommonRepository commonRepository, ILanguageRepository languageRepository)
     : base(scopeAccessor, cache, logger, commonRepository, languageRepository)
 {
 }
 public LanguageController()
 {
     this.languageRepository = new LanguageRepository();
 }
 public PageCreatedHandler(ICommandSender commandSender,
                           ILanguageRepository languageRepository)
 {
     _commandSender      = commandSender;
     _languageRepository = languageRepository;
 }
Example #53
0
 public LanguagesController(ILanguageRepository repository, ILoggerFactory loggerFactory)
 {
     this.repository = repository;
     logger          = loggerFactory.CreateLogger <LanguagesController>();
 }
 public ProcessTemplateGroupController(UserManager <SuUserModel> userManager
                                       , ILanguageRepository language
                                       , SuDbContext context) : base(userManager, language)
 {
     _context = context;
 }
 public LanguagesController(ILanguageRepository repo)
 {
     _repo = repo;
 }
Example #56
0
 public LanguagesController(ILanguageRepository repository) : base(repository)
 {
 }
Example #57
0
 public UsersController(IUserRepository repo, ILanguageRepository langRepo,IRoleRepository roleRepo)
 {
     _repo = repo;
     _langRepo = langRepo;
     _roleRepo = roleRepo;
 }
Example #58
0
 public MediaRepository(IScopeAccessor scopeAccessor, AppCaches cache, ILogger logger, IMediaTypeRepository mediaTypeRepository, ITagRepository tagRepository, ILanguageRepository languageRepository)
     : base(scopeAccessor, cache, languageRepository, logger)
 {
     _mediaTypeRepository       = mediaTypeRepository ?? throw new ArgumentNullException(nameof(mediaTypeRepository));
     _tagRepository             = tagRepository ?? throw new ArgumentNullException(nameof(tagRepository));
     _mediaByGuidReadRepository = new MediaByGuidReadRepository(this, scopeAccessor, cache, logger);
 }
 public MessagePanelItemViewModel(IDialogMessagesTab dialogMessagesTab
     , string fullName
     , ILanguageRepository languageRepository
     , ILogger logger
     , IEventAggregator eventAggregator)
     : base(languageRepository, logger, eventAggregator)
 {
     _dialogMessagesTab = dialogMessagesTab;
     FullName = fullName;
     Selected = dialogMessagesTab.Selected;
 }
Example #60
0
 public DeleteLanguageCommandHandler(ILanguageRepository languageRepository, IMediator mediator)
 {
     _languageRepository = languageRepository;
     _mediator           = mediator;
 }