public void Can_Perform_Update_On_LanguageRepository()
{
// Arrange
IScopeProvider provider = ScopeProvider;
using (provider.CreateScope())
{
LanguageRepository repository = CreateRepository(provider);
// Act
ILanguage language = repository.Get(5);
language.IsoCode = "pt-BR";
language.CultureName = "pt-BR";
language.FallbackLanguageId = 1;
repository.Save(language);
ILanguage languageUpdated = repository.Get(5);
// Assert
Assert.That(languageUpdated, Is.Not.Null);
Assert.That(languageUpdated.IsoCode, Is.EqualTo("pt-BR"));
Assert.That(languageUpdated.CultureName, Is.EqualTo("pt-BR"));
Assert.That(languageUpdated.FallbackLanguageId, Is.EqualTo(1));
}
}
public static int getIdLang(string lang)
{
Language l = LanguageRepository.SearchLanguagesByCode(lang).FirstOrDefault();
return(l.Id);
}
public void Can_Perform_Get_By_Iso_Code_On_LanguageRepository()
{
IScopeProvider provider = ScopeProvider;
using (provider.CreateScope())
{
LanguageRepository repository = CreateRepository(provider);
var au = CultureInfo.GetCultureInfo("en-AU");
var language = (ILanguage) new Language(_globalSettings, au.Name)
{
CultureName = au.DisplayName,
FallbackLanguageId = 1
};
repository.Save(language);
// re-get
language = repository.GetByIsoCode(au.Name);
// Assert
Assert.That(language, Is.Not.Null);
Assert.That(language.HasIdentity, Is.True);
Assert.That(language.CultureName, Is.EqualTo(au.DisplayName));
Assert.That(language.IsoCode, Is.EqualTo(au.Name));
Assert.That(language.FallbackLanguageId, Is.EqualTo(1));
}
}
public override void ConvertToPersistent(Language disconnectedEntity, Language persistent = null, Func <Language> populatePersistent = null)
{
populatePersistent = () =>
{
using (var uow = new Dota2UnitofWork())
{
var repository = new LanguageRepository(uow.Context);
return(repository.Select(repository.UniqueFilter(disconnectedEntity), repository.GetAllIncludes())
.Select(q => new
{
q.Id,
q.Name
})
.ToList()
.Select(ql => new Language()
{
Id = ql.Id,
Name = ql.Name
})
.SingleOrDefault());
}
};
persistent = persistent ?? populatePersistent();
if (persistent == null)
{
return;
}
base.ConvertToPersistent(disconnectedEntity, persistent, populatePersistent);
}
public void Can_Perform_Update_WithNewTranslation_On_DictionaryRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
var languageRepository = new LanguageRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of <ILogger>(), SqlSyntax);
var repository = new DictionaryRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of <ILogger>(), new SqlCeSyntaxProvider(), languageRepository);
var languageNo = new Language("nb-NO")
{
CultureName = "nb-NO"
};
ServiceContext.LocalizationService.Save(languageNo);
// Act
var item = repository.Get(1);
var translations = item.Translations.ToList();
translations.Add(new DictionaryTranslation(languageNo, "Les mer"));
item.Translations = translations;
repository.AddOrUpdate(item);
unitOfWork.Commit();
var dictionaryItem = repository.Get(1);
// Assert
Assert.That(dictionaryItem, Is.Not.Null);
Assert.That(dictionaryItem.Translations.Count(), Is.EqualTo(3));
Assert.That(dictionaryItem.Translations.Single(t => t.Language.IsoCode == "nb-NO").Value, Is.EqualTo("Les mer"));
}
// [HandleError]
protected void Application_Start()
{
ValueProviderFactories.Factories.Remove(ValueProviderFactories.Factories.OfType <System.Web.Mvc.JsonValueProviderFactory>().FirstOrDefault());
ValueProviderFactories.Factories.Add(new MyJsonValueProviderFactory());
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
FluentValidationModelValidatorProvider.Configure();
AutofacConfig.RegisterComponents();
AutoMapperConfiguration.Configure();
//try
//{
LanguageRepository.InitializeLangugae();
UnitRepository.InitializeUnit();
//}
//catch (Exception ex)
//{
// //HttpRuntime.UnloadAppDomain(); // Make sure we try to run Application_Start again next request
// // Response.Redirect("Error/Index", true);
// HttpContext.Current.Response.Redirect("Error/Index", true);
// // throw ex; // Rethrow whatever was caught
//}
}
public void Can_Perform_Add_On_LanguageRepository_With_New_Default()
{
// Arrange
IScopeProvider provider = ScopeProvider;
using (provider.CreateScope())
{
LanguageRepository repository = CreateRepository(provider);
ILanguage languageBR = new Language("pt-BR", "Portuguese (Brazil)")
{
IsDefault = true,
IsMandatory = true
};
repository.Save(languageBR);
var languageEN = new Language("en-AU", "English (Australia)");
repository.Save(languageEN);
Assert.IsTrue(languageBR.IsDefault);
Assert.IsTrue(languageBR.IsMandatory);
// Act
var languageNZ = new Language("en-NZ", "English (New Zealand)")
{
IsDefault = true,
IsMandatory = true
};
repository.Save(languageNZ);
languageBR = repository.Get(languageBR.Id);
// Assert
Assert.IsFalse(languageBR.IsDefault);
Assert.IsTrue(languageNZ.IsDefault);
}
}
private DictionaryRepository CreateRepository(IDatabaseUnitOfWork unitOfWork, out LanguageRepository languageRepository)
{
languageRepository = new LanguageRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of <ILogger>(), SqlSyntax);
var dictionaryRepository = new DictionaryRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of <ILogger>(), new SqlCeSyntaxProvider(), languageRepository);
return(dictionaryRepository);
}
public void Getting_1000_Cached_Items()
{
// Arrange
var contentType = ServiceContext.ContentTypeService.Get(NodeDto.NodeIdSeed);
var pages = MockedContent.CreateTextpageContent(contentType, -1, 1000);
ServiceContext.ContentService.Save(pages, 0);
var provider = TestObjects.GetScopeProvider(Logger);
using (var scope = provider.CreateScope())
{
var tRepository = new TemplateRepository((IScopeAccessor)provider, AppCaches.Disabled, Logger, TestObjects.GetFileSystemsMock());
var tagRepo = new TagRepository((IScopeAccessor)provider, AppCaches.Disabled, Logger);
var ctRepository = new ContentTypeRepository((IScopeAccessor)provider, AppCaches.Disabled, Logger, tRepository);
var languageRepository = new LanguageRepository((IScopeAccessor)provider, AppCaches.Disabled, Logger);
var repository = new DocumentRepository((IScopeAccessor)provider, AppCaches.Disabled, Logger, ctRepository, tRepository, tagRepo, languageRepository);
// Act
var contents = repository.GetMany();
Stopwatch watch = Stopwatch.StartNew();
var contentsCached = repository.GetMany();
watch.Stop();
var elapsed = watch.ElapsedMilliseconds;
Debug.Print("1000 content items retrieved in {0} ms with caching", elapsed);
// Assert
//Assert.That(contentsCached.Any(x => x.HasIdentity == false), Is.False);
//Assert.That(contentsCached.Any(x => x == null), Is.False);
//Assert.That(contentsCached.Count(), Is.EqualTo(contents.Count()));
}
}
//TODO into separated part
#region Constructors
public FooterViewModel()
{
_ScrollViewerModule = new ScrollViewerModule(Dispatcher);
HidePleaseWait = false;
LanguageRepository.GetAllLanguages(Languages);
CurrentLanguage = Languages.FirstOrDefault(x => x.ShortName == StationRepository.DefaultDisplayLanguage);
ScrollDownStart = new Command(OnScrollDownStartExecute);
ScrollDownStop = new Command(OnScrollDownStopExecute);
ScrollUpStart = new Command(OnScrollUpStartExecute);
ScrollUpStop = new Command(OnScrollUpStopExecute);
HideBrowserCommand = new Command(HideBrowser);
ShowTermsAndConditions = new Command(OnShowTermsAndConditionsExecute);
ShowResponsibleGaming = new Command(onShowResponsibleGaming);
ScrollToTopCommand = new Command(ScrollToTop);
Mediator.Register <int>(this, AutoLogoutWaitWindow, MsgTag.AutoLogoutWaitWindow);
Mediator.Register <string>(this, SelectLanguage, MsgTag.LanguageChosen);
Mediator.Register <bool>(this, Refresh, MsgTag.Refresh);
Mediator.Register <IMatchVw>(this, ShowStream, MsgTag.ShowStream);
Mediator.Register <bool>(this, HideStream, MsgTag.HideStream);
Mediator.Register <decimal>(this, OddPlaced, MsgTag.OddPlaced);
DataCopy.UpdateProgressBarEvent += UpdateProgress;
DataCopy.UpdateLanguagesEvent += DataCopy_UpdateLanguagesEvent;
BuildVersion = GetBuildVersion();
}
internal HttpResponseMessage LanguageGenerateCSS(HttpRequestMessage request, LanguageDTO cqDTO)
{
var lr = new LanguageRepository();
var er = new EnglishTermRepository();
var tr = new TranslatedTermRepository();
var lang = lr.GetById(int.Parse(cqDTO.LanguageID));
string cssfilename = lang.CssFileName;
var eTerms = er.GetEnglishTerms();
var tTerms = tr.GetTranslatedTerms(int.Parse(cqDTO.LanguageID));
string retVal = "";
foreach (EnglishTerm eTerm in eTerms)
{
string trans = "";
var tTerm = tTerms.Where(x => x.EnglishTermID == eTerm.EnglishTermID).FirstOrDefault();
if (tTerm != null)
{
trans = tTerm.TermTranslated;
}
retVal += "[data-test='" + eTerm.Term + "']:" + eTerm.BeforeOrAfter + " { content: '" + trans + "';}" + Environment.NewLine;
}
var res = Request.CreateResponse(HttpStatusCode.OK);
res.Content = new StringContent(retVal, Encoding.UTF8, "text/css");
return(res);
}
protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
{
lanrepo = new LanguageRepository();
qualrepo = new QualityRepository();
genrepo = new GenreRepository();
List <LanguageTable> lan = lanrepo.GetAllLanguages();
List <GenreTable> gen = genrepo.GetAllGenres();
List <QualityTable> qual = qualrepo.GetAllQualities();
DropDownList6.DataSource = lan;
DropDownList6.DataTextField = "LanguageName";
DropDownList6.DataValueField = "LanguageID";
DropDownList6.DataBind();
DropDownList7.DataSource = qual;
DropDownList7.DataTextField = "QualityName";
DropDownList7.DataValueField = "QualityID";
DropDownList7.DataBind();
DropDownList8.DataSource = gen;
DropDownList8.DataTextField = "GenreName";
DropDownList8.DataValueField = "GenreID";
DropDownList8.DataBind();
}
}
public void GetSupportedLanguages_NoneSelected_ShouldReturnEmptyList(Db db, [Content] DbTemplate template, DbItem item, string rootName)
{
template.BaseIDs = new[]
{
Templates.Site.ID, Feature.Language.Templates.LanguageSettings.ID
};
var languageItem = new DbItem("en");
db.Add(languageItem);
var siteRootItem = new DbItem(rootName, ID.NewID, template.ID)
{
new DbField(Feature.Language.Templates.LanguageSettings.Fields.SupportedLanguages)
{
{
"en", ""
}
}
};
siteRootItem.Add(item);
db.Add(siteRootItem);
var contextItem = db.GetItem(item.ID);
Context.Item = contextItem;
var supportedLanguages = LanguageRepository.GetSupportedLanguages();
supportedLanguages.Count().Should().Be(0);
}
public void GetActiveLanguagesSuccess()
{
//Arrange
var languageRepository = new LanguageRepository(_container);
var dbContext = _serviceProvider.GetRequiredService <DeviserDbContext>();
var languages = TestDataRepository.GetLanguages();
foreach (var ct in languages)
{
languageRepository.CreateLanguage(ct);
}
var inActiveLang = languages.First();
inActiveLang.IsActive = false;
languageRepository.UpdateLanguage(inActiveLang);
//Act
var result = languageRepository.GetActiveLanguages();
//Assert
Assert.NotNull(result);
Assert.True(result.Count == 2);
Assert.True(result.All(l => l.IsActive));
//Clean
dbContext.Language.RemoveRange(dbContext.Language);
}
public LanguagesViewModel()
{
Title = "Languages";
DismissCommand = ReactiveCommand.Create();
DismissCommand.Subscribe(_ => this.Dismiss());
Items = InternalItems.CreateDerivedCollection(
x => new LanguageItemViewModel(x.Name, x.Slug),
filter: x => x.Name.StartsWith(SearchKeyword ?? string.Empty, StringComparison.OrdinalIgnoreCase),
signalReset: this.WhenAnyValue(x => x.SearchKeyword));
Items
.Changed.Select(_ => Unit.Default)
.Merge(this.WhenAnyValue(x => x.SelectedLanguage).Select(_ => Unit.Default))
.Select(_ => SelectedLanguage)
.Where(x => x != null)
.Subscribe(x => {
foreach (var l in Items)
{
l.Selected = l.Slug == x.Slug;
}
});
this.WhenAnyValue(x => x.SelectedLanguage)
.IsNotNull()
.Subscribe(_ => Dismiss());
LoadCommand = ReactiveCommand.CreateAsyncTask(async t => {
var languageRepository = new LanguageRepository();
var langs = await languageRepository.GetLanguages();
langs.Insert(0, LanguageRepository.DefaultLanguage);
InternalItems.Reset(langs);
});
}
public void UpdateLanguageSuccess()
{
//Arrange
var languageRepository = new LanguageRepository(_container);
var dbContext = _serviceProvider.GetRequiredService <DeviserDbContext>();
var languages = TestDataRepository.GetLanguages();
foreach (var ct in languages)
{
languageRepository.CreateLanguage(ct);
}
var languageToUpdate = languages.First();
//Act
languageToUpdate.IsActive = false;
languageToUpdate.NativeName = "NewName";
var result = languageRepository.UpdateLanguage(languageToUpdate);
//Assert
Assert.NotNull(result);
Assert.True(result.NativeName == languageToUpdate.NativeName);
Assert.True(result.IsActive == languageToUpdate.IsActive);
//Clean
dbContext.Language.RemoveRange(dbContext.Language);
}
public void IsMultilingualFail()
{
//Arrange
var languageRepository = new LanguageRepository(_container);
var dbContext = _serviceProvider.GetRequiredService <DeviserDbContext>();
var languages = TestDataRepository.GetLanguages();
foreach (var ct in languages)
{
languageRepository.CreateLanguage(ct);
}
foreach (var lang in languages)
{
lang.IsActive = false;
languageRepository.UpdateLanguage(lang);
}
//Act
var result = languageRepository.IsMultilingual();
//Assert
Assert.True(!result);
//Clean
dbContext.Language.RemoveRange(dbContext.Language);
}
public void Can_Perform_Add_On_LanguageRepository_With_Boolean_Properties()
{
// Arrange
IScopeProvider provider = ScopeProvider;
using (provider.CreateScope())
{
LanguageRepository repository = CreateRepository(provider);
// Act
var languageBR = new Language("pt-BR", "Portuguese (Brazil)")
{
IsDefault = true,
IsMandatory = true
};
repository.Save(languageBR);
// Assert
Assert.That(languageBR.HasIdentity, Is.True);
Assert.That(languageBR.Id, Is.EqualTo(6)); // With 5 existing entries the Id should be 6
Assert.IsTrue(languageBR.IsDefault);
Assert.IsTrue(languageBR.IsMandatory);
Assert.IsNull(languageBR.FallbackLanguageId);
}
}
public JsonResult SetLanguage(int id)
{
try
{
UserRepository userrepo = new UserRepository(SessionCustom);
LanguageRepository languagerepo = new LanguageRepository(SessionCustom);
userrepo.Entity.UserId = CustomUser.UserId;
userrepo.Entity.LanguageId = id;
userrepo.Update();
languagerepo.Entity.LanguageId = id;
languagerepo.LoadByKey();
if (HttpContext.Session["lang"] == null)
{
HttpContext.Session.Add("lang", languagerepo.Entity);
}
else
{
HttpContext.Session["lang"] = languagerepo.Entity;
}
return(this.Json(new { result = true }));
}
catch (Exception)
{
return(this.Json(new { result = false }));
}
}
public void FinishUpdating()
{
LanguageRepository.Setup(x => x.GetAllLanguages(new SyncObservableCollection <Language>()));
//LanguageRepository.Expect(x => x.GetDefaultLanguage()).Return(new Language("EN"));
var model = new FooterViewModel();
model.UpdateProgress(100);
Assert.IsTrue(model.ShowProgresBar);
Assert.AreEqual(model.TotalUpdates, 100);
Assert.AreEqual(model.ProcessedUpdates, 0);
model.UpdateProgress(90);
Assert.IsTrue(model.ShowProgresBar);
Assert.AreEqual(model.TotalUpdates, 100);
Assert.AreEqual(model.ProcessedUpdates, 10);
model.UpdateProgress(0);
Assert.IsFalse(model.ShowProgresBar);
Assert.AreEqual(model.TotalUpdates, 0);
Assert.AreEqual(model.ProcessedUpdates, 0);
model.Close();
}
public AccountController(CyclepathDbContext context, IConfiguration configuration)
{
_context = new AccountRepository(context, configuration);
_themeContext = new ThemesRepository(context, configuration);
_languageContext = new LanguageRepository(context, configuration);
crypt = new MD5CryptoServiceProvider();
}
static Languages()
{
LoadedLanguages = new Dictionary <string, ILanguage>();
CompiledLanguages = new Dictionary <string, CompiledLanguage>();
LanguageRepository = new LanguageRepository(LoadedLanguages);
Load <JavaScript>();
Load <Html>();
Load <CSharp>();
Load <VbDotNet>();
Load <Ashx>();
Load <Asax>();
Load <Aspx>();
Load <AspxCs>();
Load <AspxVb>();
Load <Sql>();
Load <Xml>();
Load <Php>();
Load <Css>();
Load <Cpp>();
Load <Java>();
Load <PowerShell>();
Load <Typescript>();
Load <FSharp>();
Load <Koka>();
Load <Haskell>();
Load <Markdown>();
Load <STEP>();
}
public void GetSupportedLanguages_ShouldReturlListOfSupportedLanguages(Db db, DbItem item, string rootName)
{
var contextItemId = ID.NewID;
var rootId = ID.NewID;
var template = new DbTemplate();
template.BaseIDs = new[]
{
Foundation.MultiSite.Templates.Site.ID,
Templates.LanguageSettings.ID
};
db.Add(new DbTemplate(Foundation.MultiSite.Templates.Site.ID));
db.Add(new DbTemplate(Templates.LanguageSettings.ID));
db.Add(template);
db.Add(new DbItem(rootName, rootId, template.ID)
{
item
});
var contextItem = db.GetItem(item.ID);
Sitecore.Context.Item = contextItem;
var supportedLanguages = LanguageRepository.GetSupportedLanguages();
}
public void Can_Perform_Delete_When_Assigned_To_Doc()
{
// Arrange
using (ScopeProvider.CreateScope())
{
var templateRepository = CreateRepository(ScopeProvider);
var tagRepository = new TagRepository((IScopeAccessor)ScopeProvider, AppCaches.Disabled, Logger);
var contentTypeRepository = new ContentTypeRepository((IScopeAccessor)ScopeProvider, AppCaches.Disabled, Logger, templateRepository);
var languageRepository = new LanguageRepository((IScopeAccessor)ScopeProvider, AppCaches.Disabled, Logger);
var contentRepo = new DocumentRepository((IScopeAccessor)ScopeProvider, AppCaches.Disabled, Logger, contentTypeRepository, templateRepository, tagRepository, languageRepository);
var contentType = MockedContentTypes.CreateSimpleContentType("umbTextpage2", "Textpage");
ServiceContext.FileService.SaveTemplate(contentType.DefaultTemplate); // else, FK violation on contentType!
contentTypeRepository.Save(contentType);
var textpage = MockedContent.CreateSimpleContent(contentType);
contentRepo.Save(textpage);
var template = new Template("test", "test")
{
Content = @"<%@ Master Language=""C#"" %>"
};
templateRepository.Save(template);
textpage.TemplateId = template.Id;
contentRepo.Save(textpage);
// Act
var templates = templateRepository.Get("test");
templateRepository.Delete(templates);
// Assert
Assert.IsNull(templateRepository.Get("test"));
}
}
public void Can_get_localized_value_using_default_language()
{
// setup
var language1 = LanguageRepository.Insert(CreateLanguage(1));
var language2 = LanguageRepository.Insert(CreateLanguage(2));
var entity = new LocalizedEntity {
Id = new ObjectId(CommonHelper.CurrentTime(), 1, 2, 3)
};
LocalizedEntityService.SaveLocalizedValue(entity, (x) => x.Value1, "language 1 value 1.", language1.Id);
LocalizedEntityService.SaveLocalizedValue(entity, (x) => x.Value2, "language 1 value 2", language1.Id);
LocalizedEntityService.SaveLocalizedValue(entity, (x) => x.Value1, "language 2 value 1", language2.Id);
LocalizedEntityService.SaveLocalizedValue(entity, (x) => x.Value2, "language 2 value 2", language2.Id);
var setting = Kernel.Resolve <LocalizationSettings>();
setting.DefaultLanguageId = language2.Id;
Kernel.Resolve <ISettingService>().SaveSetting(setting);
LocalizedEntityService = Kernel.Resolve <ILocalizedEntityService>();
// act
var value1 = LocalizedEntityService.GetLocalizedValue <LocalizedEntity>(entity.Id, x => x.Value1);
var value2 = LocalizedEntityService.GetLocalizedValue <LocalizedEntity>(entity.Id, x => x.Value2);
// assert
value1.ShouldEqual("language 2 value 1");
value2.ShouldEqual("language 2 value 2");
}
public HttpResponseMessage Get()
{
var langFinal = LanguageRepository.GetAllLanguages();
HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.OK, langFinal);
return(response);
}
public HttpResponseMessage GetLanguageByName(string lang)
{
var langFinal = LanguageRepository.SearchLanguagesByCode(lang);
HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.OK, langFinal);
return(response);
}
// GET: /PolicyOtherGroupHeaderLabelLanguage/Edit
public ActionResult Edit(int id)
{
//Check Access Rights to Domain
if (!hierarchyRepository.AdminHasDomainWriteAccess(groupName))
{
ViewData["Message"] = "You do not have access to this item";
return(View("Error"));
}
//Get Item From Database
PolicyOtherGroupHeaderLabelLanguage policyOtherGroupHeaderLabelLanguage = new PolicyOtherGroupHeaderLabelLanguage();
policyOtherGroupHeaderLabelLanguage = policyOtherGroupHeaderLabelLanguageRepository.GetPolicyOtherGroupHeaderLabelLanguage(id);
//Check Exists
if (policyOtherGroupHeaderLabelLanguage == null)
{
ViewData["ActionMethod"] = "EditGet";
return(View("RecordDoesNotExistError"));
}
PolicyOtherGroupHeaderLabelLanguageVM policyOtherGroupHeaderLabelLanguageVM = new PolicyOtherGroupHeaderLabelLanguageVM();
policyOtherGroupHeaderLabelLanguageVM.PolicyOtherGroupHeaderLabelLanguage = policyOtherGroupHeaderLabelLanguage;
PolicyOtherGroupHeaderLabel policyOtherGroupHeaderLabel = new PolicyOtherGroupHeaderLabel();
policyOtherGroupHeaderLabel = policyOtherGroupHeaderLabelRepository.GetPolicyOtherGroupHeaderLabelByPolicyOtherGroupHeaderLabelId(
policyOtherGroupHeaderLabelLanguage.PolicyOtherGroupHeaderLabelId
);
if (policyOtherGroupHeaderLabel != null)
{
policyOtherGroupHeaderLabelLanguageVM.PolicyOtherGroupHeaderLabel = policyOtherGroupHeaderLabel;
}
PolicyOtherGroupHeader policyOtherGroupHeader = new PolicyOtherGroupHeader();
policyOtherGroupHeader = policyOtherGroupHeaderRepository.GetPolicyOtherGroupHeader(policyOtherGroupHeaderLabel.PolicyOtherGroupHeaderId);
if (policyOtherGroupHeader != null)
{
policyOtherGroupHeaderLabelLanguageVM.PolicyOtherGroupHeader = policyOtherGroupHeader;
}
//Languages
List <Language> availableLanguages = policyOtherGroupHeaderLabelLanguageRepository.GetAvailableLanguages(policyOtherGroupHeaderLabel.PolicyOtherGroupHeaderId).ToList();
Language selectedLanguage = new Language();
LanguageRepository languageRepository = new LanguageRepository();
selectedLanguage = languageRepository.GetLanguage(policyOtherGroupHeaderLabelLanguage.LanguageCode);
if (selectedLanguage != null)
{
availableLanguages.Add(selectedLanguage);
}
SelectList languages = new SelectList(availableLanguages.OrderBy(x => x.LanguageCode), "LanguageCode", "LanguageName", policyOtherGroupHeaderLabelLanguage.LanguageCode);
policyOtherGroupHeaderLabelLanguageVM.Languages = languages;
return(View(policyOtherGroupHeaderLabelLanguageVM));
}
public void Should_update_languages()
{
var newLanguageName1 = "New Language Name 1";
var newLanguageName2 = "New Language Name 2";
var languageToUpdate1 = LanguageFactory.Language(_siteId, _languageId1, newLanguageName1, "ab1", "ab1");
var languageToUpdate2 = LanguageFactory.Language(_siteId, _languageId2, newLanguageName2, "ab2", "ab2");
using (var context = new MSSQLDbContext(_contextOptions))
{
var repository = new LanguageRepository(DbContextShared.CreateNewContextFactory(context), Shared.CreateNewMapper());
repository.Update(new List <Language> {
languageToUpdate1, languageToUpdate2
});
}
using (var context = new MSSQLDbContext(_contextOptions))
{
var repository = new LanguageRepository(DbContextShared.CreateNewContextFactory(context), Shared.CreateNewMapper());
var updatedLanguage1 = repository.GetById(_siteId, _languageId1);
Assert.AreEqual(newLanguageName1, updatedLanguage1.Name);
}
using (var context = new MSSQLDbContext(_contextOptions))
{
var repository = new LanguageRepository(DbContextShared.CreateNewContextFactory(context), Shared.CreateNewMapper());
var updatedLanguage2 = repository.GetById(_siteId, _languageId2);
Assert.AreEqual(newLanguageName2, updatedLanguage2.Name);
}
}
public void Can_Perform_Add_On_DictionaryRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
using (var languageRepository = new LanguageRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of <ILogger>(), SqlSyntax))
using (var repository = CreateRepository(unitOfWork))
{
var language = languageRepository.Get(1);
var read = new DictionaryItem("Read");
var translations = new List <IDictionaryTranslation>
{
new DictionaryTranslation(language, "Read")
};
read.Translations = translations;
// Act
repository.AddOrUpdate(read);
unitOfWork.Commit();
var exists = repository.Exists(read.Id);
// Assert
Assert.That(read.HasIdentity, Is.True);
Assert.That(exists, Is.True);
}
}
public ActionResult Redirect()
{
var languageRepo = new LanguageRepository();
var language = languageRepo.getAvailable().First();
return RedirectToAction("Index", "Home", new { language = language.getSlug() });
}
public void Can_Instantiate_Repository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider();
var unitOfWork = provider.GetUnitOfWork();
// Act
var repository = new LanguageRepository(unitOfWork);
// Assert
Assert.That(repository, Is.Not.Null);
}
public void Can_Perform_Get_On_LanguageRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider();
var unitOfWork = provider.GetUnitOfWork();
var repository = new LanguageRepository(unitOfWork);
// Act
var language = repository.Get(1);
// Assert
Assert.That(language, Is.Not.Null);
Assert.That(language.HasIdentity, Is.True);
Assert.That(language.CultureName, Is.EqualTo("en-US"));
Assert.That(language.IsoCode, Is.EqualTo("en-US"));
}
public void Can_Perform_GetAll_With_Params_On_LanguageRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider();
var unitOfWork = provider.GetUnitOfWork();
var repository = new LanguageRepository(unitOfWork);
// Act
var languages = repository.GetAll(1, 2);
// Assert
Assert.That(languages, Is.Not.Null);
Assert.That(languages.Any(), Is.True);
Assert.That(languages.Any(x => x == null), Is.False);
Assert.That(languages.Count(), Is.EqualTo(2));
}
public static void RegisterRoutes(RouteCollection routes)
{
routes.IgnoreRoute("{resource}.axd/{*pathInfo}");
var languageRepo = new LanguageRepository();
routes.MapRoute(
name: "Default",
url: "",
defaults: new { controller = "Utils", action = "Redirect" }
);
routes.MapRoute(
name: null,
url: "{language}/{controller}/{action}/{id}",
defaults: new { language = "es-ES", controller = "Home", action = "Index", id = UrlParameter.Optional }
);
}
public void Can_Perform_GetAll_On_DictionaryRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider();
var unitOfWork = provider.GetUnitOfWork();
var languageRepository = new LanguageRepository(unitOfWork);
var repository = new DictionaryRepository(unitOfWork, languageRepository);
// Act
var dictionaryItem = repository.Get(1);
var dictionaryItems = repository.GetAll();
// Assert
Assert.That(dictionaryItems, Is.Not.Null);
Assert.That(dictionaryItems.Any(), Is.True);
Assert.That(dictionaryItems.Any(x => x == null), Is.False);
Assert.That(dictionaryItems.Count(), Is.EqualTo(2));
}
public void Can_Perform_Get_On_DictionaryRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider();
var unitOfWork = provider.GetUnitOfWork();
var languageRepository = new LanguageRepository(unitOfWork);
var repository = new DictionaryRepository(unitOfWork, languageRepository);
// Act
var dictionaryItem = repository.Get(1);
// Assert
Assert.That(dictionaryItem, Is.Not.Null);
Assert.That(dictionaryItem.ItemKey, Is.EqualTo("Read More"));
Assert.That(dictionaryItem.Translations.Any(), Is.True);
Assert.That(dictionaryItem.Translations.Any(x => x == null), Is.False);
Assert.That(dictionaryItem.Translations.First().Value, Is.EqualTo("Read More"));
Assert.That(dictionaryItem.Translations.Last().Value, Is.EqualTo("Læs mere"));
}
public void Can_Perform_Exists_On_DictionaryRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider();
var unitOfWork = provider.GetUnitOfWork();
var languageRepository = new LanguageRepository(unitOfWork);
var repository = new DictionaryRepository(unitOfWork, languageRepository);
// Act
var exists = repository.Exists(1);
// Assert
Assert.That(exists, Is.True);
}
public void Can_Perform_GetByQuery_On_DictionaryRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider();
var unitOfWork = provider.GetUnitOfWork();
var languageRepository = new LanguageRepository(unitOfWork);
var repository = new DictionaryRepository(unitOfWork, languageRepository);
// Act
var query = Query<IDictionaryItem>.Builder.Where(x => x.ItemKey == "Article");
var result = repository.GetByQuery(query);
// Assert
Assert.That(result, Is.Not.Null);
Assert.That(result.Any(), Is.True);
Assert.That(result.FirstOrDefault().ItemKey, Is.EqualTo("Article"));
}
public LocalizedResourceServices(PXHotelEntities entities)
{
_localizedResourceRepository = new LocalizedResourceRepository(entities);
_languageRepository = new LanguageRepository(entities);
}
public void Can_Perform_Count_On_LanguageRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider();
var unitOfWork = provider.GetUnitOfWork();
var repository = new LanguageRepository(unitOfWork);
// Act
var query = Query<ILanguage>.Builder.Where(x => x.IsoCode.StartsWith("D"));
int count = repository.Count(query);
// Assert
Assert.That(count, Is.EqualTo(2));
}
private DictionaryRepository CreateRepository(IDatabaseUnitOfWork unitOfWork, out LanguageRepository languageRepository)
{
languageRepository = new LanguageRepository(unitOfWork, NullCacheProvider.Current);
var dictionaryRepository = new DictionaryRepository(unitOfWork, NullCacheProvider.Current, languageRepository);
return dictionaryRepository;
}
public void Can_Perform_Update_On_LanguageRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider();
var unitOfWork = provider.GetUnitOfWork();
var repository = new LanguageRepository(unitOfWork);
// Act
var language = repository.Get(5);
language.IsoCode = "pt-BR";
language.CultureName = "pt-BR";
repository.AddOrUpdate(language);
unitOfWork.Commit();
var languageUpdated = repository.Get(5);
// Assert
Assert.That(languageUpdated, Is.Not.Null);
Assert.That(languageUpdated.IsoCode, Is.EqualTo("pt-BR"));
Assert.That(languageUpdated.CultureName, Is.EqualTo("pt-BR"));
}
public void Can_Perform_Delete_On_LanguageRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider();
var unitOfWork = provider.GetUnitOfWork();
var repository = new LanguageRepository(unitOfWork);
// Act
var language = repository.Get(3);
repository.Delete(language);
unitOfWork.Commit();
var exists = repository.Exists(3);
// Assert
Assert.That(exists, Is.False);
}
public void Can_Perform_Exists_On_LanguageRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider();
var unitOfWork = provider.GetUnitOfWork();
var repository = new LanguageRepository(unitOfWork);
// Act
var exists = repository.Exists(3);
var doesntExist = repository.Exists(10);
// Assert
Assert.That(exists, Is.True);
Assert.That(doesntExist, Is.False);
}
public void Can_Perform_Add_On_DictionaryRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider();
var unitOfWork = provider.GetUnitOfWork();
var languageRepository = new LanguageRepository(unitOfWork);
var repository = new DictionaryRepository(unitOfWork, languageRepository);
var language = languageRepository.Get(1);
var read = new DictionaryItem("Read");
var translations = new List<IDictionaryTranslation>
{
new DictionaryTranslation(language, "Read")
};
read.Translations = translations;
// Act
repository.AddOrUpdate(read);
unitOfWork.Commit();
var exists = repository.Exists(read.Id);
// Assert
Assert.That(read.HasIdentity, Is.True);
Assert.That(exists, Is.True);
}
public void Can_Perform_GetByQuery_On_LanguageRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider();
var unitOfWork = provider.GetUnitOfWork();
var repository = new LanguageRepository(unitOfWork);
// Act
var query = Query<ILanguage>.Builder.Where(x => x.IsoCode == "da-DK");
var result = repository.GetByQuery(query);
// Assert
Assert.That(result, Is.Not.Null);
Assert.That(result.Any(), Is.True);
Assert.That(result.FirstOrDefault().CultureName, Is.EqualTo("da-DK"));
}
public LanguageServices(PXHotelEntities entities)
{
_localizedResourceServices = HostContainer.GetInstance<ILocalizedResourceServices>();
_languageRepository = new LanguageRepository(entities);
}
public void Can_Perform_Update_On_DictionaryRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider();
var unitOfWork = provider.GetUnitOfWork();
var languageRepository = new LanguageRepository(unitOfWork);
var repository = new DictionaryRepository(unitOfWork, languageRepository);
// Act
var item = repository.Get(1);
var translations = item.Translations.ToList();
translations[0].Value = "Read even more";
item.Translations = translations;
repository.AddOrUpdate(item);
unitOfWork.Commit();
var dictionaryItem = repository.Get(1);
// Assert
Assert.That(dictionaryItem, Is.Not.Null);
Assert.That(dictionaryItem.Translations.Count(), Is.EqualTo(2));
Assert.That(dictionaryItem.Translations.FirstOrDefault().Value, Is.EqualTo("Read even more"));
}
public void Can_Perform_Count_On_DictionaryRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider();
var unitOfWork = provider.GetUnitOfWork();
var languageRepository = new LanguageRepository(unitOfWork);
var repository = new DictionaryRepository(unitOfWork, languageRepository);
// Act
var query = Query<IDictionaryItem>.Builder.Where(x => x.ItemKey.StartsWith("Read"));
var result = repository.Count(query);
// Assert
Assert.That(result, Is.EqualTo(1));
}
public void Can_Perform_Add_On_LanguageRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider();
var unitOfWork = provider.GetUnitOfWork();
var repository = new LanguageRepository(unitOfWork);
// Act
var languageBR = new Language("pt-BR") { CultureName = "pt-BR" };
repository.AddOrUpdate(languageBR);
unitOfWork.Commit();
// Assert
Assert.That(languageBR.HasIdentity, Is.True);
Assert.That(languageBR.Id, Is.EqualTo(6));//With 5 existing entries the Id should be 6
}
