public List <LanguageViewModel> GetAll(string columnName, string searchString, Guid countryId)
{
List <Language> entities;
switch (columnName.ToLower())
{
case "languagename":
entities = _repository.GetByLanguageName(searchString, countryId);
break;
case "languageshortname":
entities = _repository.GetByLanguageShortName(searchString, countryId);
break;
default:
entities = _repository.GetAll(countryId);
break;
}
if (entities == null)
{
throw new Exception(LOCALIZATION_LANGUAGE_NOT_FOUND);
}
return(LanguagesMapper.MapToViewModel(entities));
}
public IEnumerable <LanguageInfo> GetAllActive(Guid siteId)
{
return(_cacheManager.Get(string.Format(CacheKeys.LanguagesCacheKey, siteId), () =>
{
var languages = _languageRepository.GetAll(siteId).Where(x => x.Status != LanguageStatus.Deleted);
return _mapper.Map <IEnumerable <LanguageInfo> >(languages);
}));
}
public IActionResult Create()
{
var model = new ContentModel();
model.Languages = _languageRepository.GetAll().ToList();
//get mapping proporties
AddLocales(_languageRepository, model.Locales);
return(View(model));
}
public IActionResult Index()
{
if (HttpContext.Session.GetString("user") is null)
{
Response.Redirect("/admin/login");
}
ViewBag.User = HttpContext.Session.GetString("user");
var languages = _repository.GetAll();
return(View(languages));
}
public IEnumerable <LanguageModel> Get()
{
var languages = _languageRepository.GetAll();
if (!languages.Any()) // None, load from CSV
{
LoadLanguagesFromCSV(System.IO.Path.Combine(System.Web.Hosting.HostingEnvironment.MapPath("/App_Data"), "Languages.txt"), _languageRepository);
languages = _languageRepository.GetAll();
}
return(_mapper.Map <List <LanguageModel> >(languages));
}
/// <summary>
/// Get all languages defined in the system
/// </summary>
/// <returns></returns>
public IEnumerable <LanguageViewModel> GetAllLanguages()
{
var language = _languageRepository.GetAll();
var languageViewMdoel = language.ConvertToLanguageViewModelList();
return(languageViewMdoel);
}
protected void Application_AcquireRequestState(object sender, EventArgs e)
{
if (HttpContext.Current.Session != null)
{
CultureInfo ci = (CultureInfo)Session["Culture"];
if (ci == null)
{
string lang = "en";
if (HttpContext.Current.Request.UserLanguages != null && HttpContext.Current.Request.UserLanguages.Length != 0)
{
lang = HttpContext.Current.Request.UserLanguages[0].Substring(0, 2);
}
if (lang.Equals("ru"))
{
lang = "uk";
}
else if (_LanguageRepository.GetAll().Count(x => x.Code.Equals(lang)) == 0)
{
lang = "en";
}
ci = new CultureInfo(lang);
Session["Culture"] = ci;
}
Thread.CurrentThread.CurrentUICulture = ci;
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture(ci.Name);
}
}
public IDataResult <List <Page <LanguageDto> > > GetPaginatedLanguages(int startPageNumber, int endPageNumber, int pageSize)
{
var languages = _languageRepository.GetAll().Where(x => x.IsActive).ProjectTo <LanguageDto>(_mapper.ConfigurationProvider);
var languageDtos = Page <LanguageDto> .CreatePaginatedResultList(languages, startPageNumber, endPageNumber, pageSize);
return(new SuccessDataResult <List <Page <LanguageDto> > >(Messages.SuccessOperation, languageDtos));
}
public async Task <IEnumerable <Language> > Get()
{
IEnumerable <Language> languages = null;
if (_cache.TryGetValue(LanguageCacheKey, out languages))
{
return(languages);
}
await semaphoreSlim.WaitAsync();
try
{
if (_cache.TryGetValue(LanguageCacheKey, out languages))
{
return(languages.ToList());
}
languages = await _repository.GetAll();
var cacheExpirationOptions = new MemoryCacheEntryOptions();
cacheExpirationOptions.AbsoluteExpiration = DateTime.Now.AddHours(4);
cacheExpirationOptions.Priority = CacheItemPriority.Normal;
_cache.Set(LanguageCacheKey, languages, cacheExpirationOptions);
return(languages.ToList());;
}
finally
{
semaphoreSlim.Release();
}
}
public TextModuleAdminModel GetAdminModel(Guid siteId, Guid moduleId, Guid versionId = new Guid())
{
var module = _moduleRepository.GetById(siteId, moduleId);
if (module == null || module.Status == ModuleStatus.Deleted)
{
return(new TextModuleAdminModel());
}
var textModule = _textRepository.GetByModuleId(moduleId);
if (textModule == null || textModule.Status == TextModuleStatus.Deleted)
{
return(new TextModuleAdminModel());
}
var version = versionId != Guid.Empty
? textModule.TextVersions.FirstOrDefault(x => x.Id == versionId)
: textModule.TextVersions.FirstOrDefault(x => x.Status == TextVersionStatus.Published);
if (version == null || version.Status == TextVersionStatus.Deleted)
{
return(new TextModuleAdminModel());
}
var result = new TextModuleAdminModel
{
Id = textModule.Id,
ModuleId = textModule.ModuleId,
Content = version.Content,
Description = version.Description
};
var languages = _languageRepository.GetAll(siteId).Where(x => x.Status != LanguageStatus.Deleted);
foreach (var language in languages)
{
var content = string.Empty;
var existingLocalisation = version
.TextLocalisations
.FirstOrDefault(x => x.LanguageId == language.Id);
if (existingLocalisation != null)
{
content = existingLocalisation.Content;
}
result.VersionLocalisations.Add(new TextModuleAdminModel.VersionLocalisation
{
LanguageId = language.Id,
LanguageName = language.Name,
Content = content
});
}
return(result);
}
public IActionResult GetLanguage()
{
var results = new ObjectResult(_languageRepository.GetAll())
{
StatusCode = (int)HttpStatusCode.OK
};
return(results);
}
public ActionResult <IEnumerable <LanguageDTO> > GetLanguages()
{
var service = _languageRepository.GetAll();
if (service.Count == 0)
{
return(NotFound());
}
return(Ok(_mapper.Map <IEnumerable <LanguageDTO> >(service)));
}
public SiteAdminModel GetAdminModel(Guid id)
{
var site = _siteRepository.GetById(id);
if (site == null)
{
return(null);
}
var model = _mapper.Map <SiteAdminModel>(site);
model.SiteLocalisations.Clear();
foreach (var language in _languageRepository.GetAll(id))
{
var title = string.Empty;
var metaDescription = string.Empty;
var metaKeywords = string.Empty;
var existingLocalisation = site
.SiteLocalisations
.FirstOrDefault(x => x.LanguageId == language.Id);
if (existingLocalisation != null)
{
title = existingLocalisation.Title;
metaDescription = existingLocalisation.MetaDescription;
metaKeywords = existingLocalisation.MetaKeywords;
}
model.SiteLocalisations.Add(new SiteLocalisationAdminModel
{
SiteId = site.Id,
LanguageId = language.Id,
LanguageName = language.Name,
LanguageStatus = language.Status,
Title = title,
MetaDescription = metaDescription,
MetaKeywords = metaKeywords
});
}
foreach (var page in _pageFacade.GetAllForAdmin(id).Where(x => x.Status == PageStatus.Active))
{
model.Pages.Add(new PageListAdminModel
{
Id = page.Id,
Name = page.Name
});
}
return(model);
}
/// <summary>
/// Gets the languages from the database.
/// </summary>
private async Task <IEnumerable <Language> > GetLanguages()
{
var types = _cache?.Get <IEnumerable <Language> >(CacheKey);
if (types == null)
{
types = await _repo.GetAll().ConfigureAwait(false);
_cache?.Set(CacheKey, types);
}
return(types);
}
public async Task <MenuItemAdminModel> GetItemForAdminAsync(Guid siteId, Guid menuId, Guid menuItemId)
{
var menu = _menuRepository.GetById(siteId, menuId);
if (menu == null || menu.Status == MenuStatus.Deleted)
{
return(new MenuItemAdminModel());
}
var menuItem = menu.MenuItems.FirstOrDefault(x => x.Id == menuItemId);
if (menuItem == null || menuItem.Status == MenuItemStatus.Deleted)
{
return(new MenuItemAdminModel());
}
var result = new MenuItemAdminModel
{
Id = menuItem.Id,
MenuItemType = menuItem.MenuItemType,
PageId = menuItem.PageId,
Link = menuItem.Link,
Text = menuItem.Text,
Title = menuItem.Title
};
var languages = _languageRepository.GetAll(siteId);
foreach (var language in languages)
{
var text = string.Empty;
var title = string.Empty;
var existingLocalisation = menuItem.MenuItemLocalisations.FirstOrDefault(x => x.LanguageId == language.Id);
if (existingLocalisation != null)
{
text = existingLocalisation.Text;
title = existingLocalisation.Title;
}
result.MenuItemLocalisations.Add(new MenuItemAdminModel.MenuItemLocalisation
{
LanguageId = language.Id,
LanguageName = language.Name,
Text = text,
Title = title
});
}
return(result);
}
public async Task <IActionResult> ExecuteAsync(CancellationToken cancellationToken)
{
var languages = await _languageRepository.GetAll(cancellationToken);
if (languages == null)
{
return(new NotFoundResult());
}
languages = languages.Where(x => x.Active).ToList();
var languageViewModel = _languageMapper.MapList(languages);
return(new OkObjectResult(languageViewModel));
}
public async Task <IActionResult> GetAll()
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var languages = await _languageRepository.GetAll();
var languagesResource = _mapper.Map <List <LanguageResource> >(languages);
return(Ok(languagesResource));
}
protected virtual void AddLocales <TLocalizedModelLocal>(ILanguageRepository languageService, IList <TLocalizedModelLocal> locales, Action <TLocalizedModelLocal, int> configure) where TLocalizedModelLocal : ILocalizedModelLocal
{
foreach (var language in languageService.GetAll())
{
var locale = Activator.CreateInstance <TLocalizedModelLocal>();
locale.LanguageId = language.Id;
if (configure != null)
{
configure.Invoke(locale, locale.LanguageId);
}
locales.Add(locale);
}
}
public ListModelBase <CustomAppointmentsBookedModel, CustomAppointmentsBookedListModelFilter> GetCustomAppointmentsBooked(int pageNumber, int pageSize, ModelFilterBase filter, out int totalRecords)
{
var customFilter = filter as CustomAppointmentsBookedListModelFilter;
customFilter = customFilter ?? new CustomAppointmentsBookedListModelFilter();
var appFilter = new AppointmentsBookedListModelFilter
{
AccountId = customFilter.AccountId,
FromDate = customFilter.FromDate,
ToDate = customFilter.ToDate,
Tag = customFilter.Tag
};
var eventCustomers = _eventCustomerRepository.GetEventCustomersbyRegisterationDate(pageNumber, pageSize, appFilter, out totalRecords);
if (eventCustomers.IsNullOrEmpty())
{
return(null);
}
var appointments = _appointmentRepository.GetByIds(eventCustomers.Where(ec => ec.AppointmentId.HasValue).Select(ec => ec.AppointmentId.Value).ToList());
var eventIds = eventCustomers.Select(ec => ec.EventId).Distinct().ToArray();
var model = _eventReportingService.GetEventVolumeModel(eventCustomers.Select(ec => ec.EventId).Distinct().ToArray());
var customers = _customerRepository.GetCustomers(eventCustomers.Select(ec => ec.CustomerId).Distinct().ToArray());
var customerIds = customers.Select(x => x.CustomerId);
var orders = _orderRepository.GetAllOrdersByEventCustomerIds(eventCustomers.Select(ec => ec.Id).ToArray(), true);
var eventPackages = _eventPackageRepository.GetbyEventIds(eventIds);
var eventTests = _eventTestRepository.GetByEventIds(eventIds);
var orgRoleUserIds = eventCustomers.Where(ec => ec.DataRecorderMetaData != null && ec.DataRecorderMetaData.DataRecorderCreator != null).Select(ec => ec.DataRecorderMetaData.DataRecorderCreator.Id).ToList();
var eventAppointmentChangeLogs = _eventAppointmentChangeLogRepository.GetByEventCustomerIds(eventCustomers.Select(ec => ec.Id).ToArray()).ToArray();
orgRoleUserIds.AddRange(eventAppointmentChangeLogs.Select(eacl => eacl.CreatedByOrgRoleUserId));
var registeredbyAgent = _organizationRoleUserRepository.GetOrganizationRoleUsers(orgRoleUserIds);
var roles = _roleRepository.GetAll();
var registeredbyAgentNameIdPair = _organizationRoleUserRepository.GetNameIdPairofUsers(orgRoleUserIds.ToArray()).ToArray();
var primaryCarePhysicians = _primaryCarePhysicianRepository.GetByCustomerIds(eventCustomers.Select(ec => ec.CustomerId).Distinct().ToArray());
var languages = _languageRepository.GetAll();
return(_customAppointmentsBookedModelFactory.Create(eventCustomers, appointments, orders, model, customers, registeredbyAgent,
roles, registeredbyAgentNameIdPair, eventAppointmentChangeLogs, primaryCarePhysicians, eventPackages, eventTests, languages));
}
/// <summary>
/// Resolves all queries on guest accesses
/// </summary>
/// <param name="graphQlQuery"></param>
public void ResolveQuery(GraphQlQuery graphQlQuery)
{
// LANGUAGES: a list of all lang codes
graphQlQuery.FieldAsync <ListGraphType <LanguageType> >(
"languages",
resolve: async(context) =>
{
var languages = await _languageRepository.GetAll();
// map entity to model
return(_mapper.Map <List <LanguageModel> >(languages));
}
);
}
public string GetLang(string key)
{
var lsModel = _ILang.GetAll();
var model = lsModel.FirstOrDefault(x => x.Key_Language == key);
var Language = _httpContextAccessor.HttpContext.Session.GetString("LanguageCurrent");
if (Language == "VN")
{
return(model.Language_VN);
}
else
{
return(model.Language_EN);
}
}
protected override IDictionaryItem PerformGet(int id)
{
var sql = GetBaseQuery(false)
.Where(GetBaseWhereClause(), new { Id = id })
.OrderBy <DictionaryDto>(x => x.UniqueId, SqlSyntax);
var dto = Database.Fetch <DictionaryDto, LanguageTextDto, DictionaryDto>(new DictionaryLanguageTextRelator().Map, sql).FirstOrDefault();
if (dto == null)
{
return(null);
}
//This will be cached
var allLanguages = _languageRepository.GetAll().ToArray();
var entity = ConvertFromDto(dto, allLanguages);
//on initial construction we don't want to have dirty properties tracked
// http://issues.umbraco.org/issue/U4-1946
((Entity)entity).ResetDirtyProperties(false);
return(entity);
}
public void pullSelect()
{
var author = authorRepository.GetAll()
.Where(x => x.isApproved)
.Select(x => new
{
selectname = x.Id,
fullname = x.Name + " " + x.Surname
});
ViewBag.Types = new SelectList(typeRepository.GetAll(), "TypeId", "Name");
ViewBag.Authors = new SelectList(author, "selectname", "fullname");
ViewBag.Publisher = new SelectList(publisherRepository.GetAll(), "PublisherId", "Name");
ViewBag.Language = new SelectList(languageRepository.GetAll(), "LanguageId", "Name");
}
/// <summary>
/// Получить все поддерживаемые языки
/// </summary>
public async Task <Result <IList <LanguageDto> > > GetAll()
{
using (_unitOfWork.Begin())
{
IList <Language> languages = await _languageRepository.GetAll();
if (languages == null || languages.Count == 0)
{
_logger.Warning("LanguageService. Languages has not been found");
return(Result.Failure <IList <LanguageDto> >(ErrorCodes.LanguagesNotFound));
}
var languageDtos = _mapper.Map <IList <LanguageDto> >(languages);
return(Result.Success(languageDtos));
}
}
public async Task <IActionResult> ExecuteAsync(SaveLanguage saveLanguage, CancellationToken cancellationToken)
{
var listLanguage = await _languageRepository.GetAll(cancellationToken);
var count = listLanguage.SingleOrDefault(x => x.Code == saveLanguage.Code);
if (count != null)
{
return(new ConflictResult());
}
var language = _saveLanguageToLanguageMapper.Map(saveLanguage);
//// add created by
//var user = _httpContextAccessor.HttpContext.User;
//if (user == null)
// return new NotFoundResult();
//var claims = user.Claims.ToList();
//if (claims.Count < 1)
// return new NotFoundResult();
//var userId = claims.FirstOrDefault(claimRecord => claimRecord.Type == "sub").Value;
//if (language.CreatedBy == null)
// language.CreatedBy = userId;
//language.ModifiedBy = userId;
//// end created by
language = await _languageRepository.Add(language, cancellationToken);
if (language.IsDefault == true)
{
language = await _languageRepository.UpdateDefault(language, cancellationToken);
}
var languageViewModel = _languageToLanguageMapper.Map(language);
return(new CreatedAtRouteResult(LanguagesControllerRoute.GetLanguage, new { id = languageViewModel.Id },
languageViewModel));
}
/// <summary>
/// Gets all languages
/// </summary>
/// <param name="storeId">Load records allowed only in a specified store; pass 0 to load all records</param>
/// <param name="showHidden">A value indicating whether to show hidden records</param>
/// <returns>Languages</returns>
public virtual IList <Language> GetAllLanguages(bool showHidden = false, int storeId = 0)
{
string key = string.Format(LANGUAGES_ALL_KEY, showHidden);
var languages = _cacheManager.GetCache(CACHE_NAME_LANUAGE).Get(key, () =>
{
var query = _languageRepository.GetAll();
if (!showHidden)
{
query = query.Where(l => l.Published);
}
query = query.OrderBy(l => l.DisplayOrder);
return(query.ToList());
});
//store mapping
if (storeId > 0)
{
languages = languages
.Where(l => _storeMappingService.Authorize(l, storeId))
.ToList();
}
return(languages);
}
public async Task <IActionResult> ExecuteAsync(string all, PageOptions pageOptions, CancellationToken cancellationToken)
{
if (all == "1")
{
var language = await _languageRepository.GetAll(cancellationToken);
if (language == null)
{
return(new NoContentResult());
}
return(new OkObjectResult(language));
}
var languages = await _languageRepository.GetPage(pageOptions.Page.Value, pageOptions.Count.Value, cancellationToken);
if (languages == null)
{
return(new NoContentResult());
}
var(totalCount, totalPages) = await _languageRepository.GetTotalPages(pageOptions.Count.Value, cancellationToken);
var languageViewModels = _languageMapper.MapList(languages);
var page = new PageResult <Language>()
{
Count = pageOptions.Count.Value,
Items = languageViewModels,
Page = pageOptions.Page.Value,
TotalCount = totalCount,
TotalPages = totalPages,
};
return(new OkObjectResult(page));
}
public IActionResult GetAll([FromQuery] QueryParameters queryParameters)
{
List <Models.Language> allLanguage = _languageRepository.GetAll(queryParameters).ToList();
return(Ok(allLanguage));
}
public IEnumerable <Language> GetAll()
{
return(_languageRepository.GetAll());
}
public async Task <IActionResult> GetLanguages()
{
var languages = await languageRepository.GetAll();
return(Ok(mapper.Map <IEnumerable <Resources.KeyValuePair> >(languages)));
}
