/// <summary> /// Merges the explicitly provided values with the extra object /// </summary> /// <param name="explicitValues">The explicit values.</param> /// <param name="extra">The extra.</param> /// <returns></returns> public Dictionary <string, string> Merge(Dictionary <string, string> explicitValues, object extra = null) { var merged = explicitValues; if (AuthenticationStyle == AuthenticationStyle.PostValues) { merged.Add(OidcConstants.TokenRequest.ClientId, ClientId); if (ClientSecret.IsPresent()) { merged.Add(OidcConstants.TokenRequest.ClientSecret, ClientSecret); } } var additionalValues = ValuesHelper.ObjectToDictionary(extra); if (additionalValues != null) { merged = explicitValues.Concat(additionalValues.Where(add => !explicitValues.ContainsKey(add.Key))) .ToDictionary(final => final.Key, final => final.Value); } return(merged); }
/// <summary> /// Return a <see cref="ContentResult"/> that automatically POSTs the values. /// </summary> /// <param name="url">Where to post the values.</param> /// <param name="values">The values to post.</param> /// <returns></returns> // ReSharper disable once UnusedMember.Local private ContentResult Post(string url, object values) { var response = HttpContext.Response; response.Clear(); var p = ValuesHelper.ObjectToDictionary(values); var s = new StringBuilder(); s.Append("<html><head><title></title></head>"); s.Append("<body onload='document.forms[\"form\"].submit()'>"); s.Append($"<form name='form' action='{url}' method='post'>"); foreach (var pair in p) { s.Append($"<input type='hidden' name='{pair.Key}' value='{pair.Value}' />"); } s.Append("</form></body></html>"); return(new ContentResult { Content = s.ToString(), ContentType = "text/html", StatusCode = StatusCodes.Status200OK }); }
public void Check_That_nonPublished_Article_notLoaded([Values(ContentAccess.Live)] ContentAccess access, [MappingValues] Mapping mapping) { using (var context = GetDataContext(access, mapping)) { var status = ValuesHelper.GetNonPublishedStatus(mapping); var nonpublishedItems = context.PublishedNotPublishedItems.Where(x => x.StatusTypeId == status).ToArray(); Assert.That(nonpublishedItems, Is.Null.Or.Empty); } }
public void Check_That_nonPublished_Article_isLoaded([Values(ContentAccess.StageNoDefaultFiltration)] ContentAccess access, [MappingValues] Mapping mapping) { using (var context = GetDataContext(access, mapping)) { var status = ValuesHelper.GetNonPublishedStatus(mapping); var items = context.PublishedNotPublishedItems.Where(x => x.StatusTypeId == status).ToArray(); Assert.That(items, Is.Not.Null.And.Not.Empty); } }
public void Check_That_FileFieldUploadPath_isCorrect_Fill([ContentAccessValues] ContentAccess access, [MappingValues] Mapping mapping) { using (var context = GetDataContext(access, mapping)) { var items = context.FileFieldsItems.FirstOrDefault(); var expectedUploadPath = UPLOAD_PATH + ValuesHelper.GetFileContentId(mapping); Assert.That(items.FileItemUploadPath, Is.EqualTo(expectedUploadPath)); } }
public void DataContext_Schema_GetContentInfo([ContentAccessValues] ContentAccess access, [MappingValues] Mapping mapping) { using (var context = GetDataContext(access, mapping)) { var contentId = context.GetInfo <Schema>().Id; int expectedContentId = ValuesHelper.GetSchemaContentId(mapping); Assert.That(contentId, Is.EqualTo(expectedContentId)); } }
public void DataContext_Schema_GetAttributeInfo([ContentAccessValues] ContentAccess access, [MappingValues] Mapping mapping) { using (var context = GetDataContext(access, mapping)) { var attributeId = context.GetInfo <Schema>(a => a.Title).Id; var expectedattributeId = ValuesHelper.GetSchemaTitleFieldId(mapping); Assert.That(attributeId, Is.EqualTo(expectedattributeId)); } }
/// <summary> /// Creates URL based on key/value input pairs. /// </summary> /// <param name="values">The values (either as a Dictionary of string/string or as a type with properties).</param> /// <returns></returns> public string Create(object values) { var dictionary = ValuesHelper.ObjectToDictionary(values); if (dictionary == null || !dictionary.Any()) { return(_baseUrl); } return(QueryHelpers.AddQueryString(_baseUrl, dictionary)); }
private string ExpectedUploadUrl(string pref, string fileName, Mapping mapping) { if (string.IsNullOrEmpty(pref)) { return(String.Format("{0}{1}/{2}", UploadUrlRel, ValuesHelper.GetFileContentId(mapping), fileName)); } else { return(String.Format("{0}{1}/{2}", UploadUrlAbs, ValuesHelper.GetFileContentId(mapping), fileName)); } }
/// <summary> /// Creates URL based on key/value input pairs. /// </summary> /// <param name="values">The values (either as a Dictionary of string/string or as a type with properties).</param> /// <returns></returns> public string Create(object values) { var dictionary = ValuesHelper.ObjectToDictionary(values); if (dictionary == null || !dictionary.Any()) { return(_baseUrl); } var qs = string.Join("&", dictionary.Select(kvp => string.Format("{0}={1}", WebUtility.UrlEncode(kvp.Key), WebUtility.UrlEncode(kvp.Value))).ToArray()); return(string.Format("{0}?{1}", _baseUrl, qs)); }
public IActionResult OnGet() { var time = DateTime.Now; var isMorning = time.Hour < 12; Workout = new WorkoutCreateViewModel { Date = time.Date, Name = ValuesHelper.ComposeWorkoutName(time, isMorning), Place = _configuration["DefaultSwimPlace"], IsMorning = isMorning }; return(Page()); }
/// <summary> /// Creates a end_session URL. /// </summary> /// <param name="request">The request.</param> /// <param name="idTokenHint">The id_token hint.</param> /// <param name="postLogoutRedirectUri">The post logout redirect URI.</param> /// <param name="state">The state.</param> /// <param name="extra">The extra parameters.</param> /// <returns></returns> public static string CreateEndSessionUrl(this RequestUrl request, string idTokenHint = null, string postLogoutRedirectUri = null, string state = null, object extra = null) { var values = new Dictionary <string, string>(); values.AddOptional(OidcConstants.EndSessionRequest.IdTokenHint, idTokenHint); values.AddOptional(OidcConstants.EndSessionRequest.PostLogoutRedirectUri, postLogoutRedirectUri); values.AddOptional(OidcConstants.EndSessionRequest.State, state); return(request.Create(ValuesHelper.Merge(values, ValuesHelper.ObjectToDictionary(extra)))); }
/// <summary> /// Creates URL based on key/value input pairs. /// </summary> /// <param name="values">The values (either as a Dictionary of string/string or as a type with properties).</param> /// <returns></returns> public string Create(object values) { var dictionary = ValuesHelper.ObjectToDictionary(values); if (dictionary == null || !dictionary.Any()) { return(_baseUrl); } var encoder = UrlEncoder.Default; var qs = string.Join("&", dictionary.Where(d => d.Value != null).Select(kvp => string.Format("{0}={1}", encoder.Encode(kvp.Key), encoder.Encode(kvp.Value))).ToArray()); return(string.Format("{0}?{1}", _baseUrl, qs)); }
public IActionResult GetWorkoutName(DateTime selectedDate, bool isMorning) { string result; if (selectedDate > DateTime.MinValue) { //if (!string.IsNullOrEmpty(value) && DateTime.TryParse(value, out DateTime date)) //{ // var dateAndTime = new DateTime(date.Year, date.Month, date.Day, DateTime.Now.Hour, 0, 0); result = ValuesHelper.ComposeWorkoutName(selectedDate, isMorning); } else { result = string.Empty; } return(new JsonResult(result)); }
public async Task OnGetAsync(int?pageNo) { var pageIndex = ValuesHelper.GetPageIndex(pageNo); //static IQueryable<Workout> queryModifier(IQueryable<Workout> q) => q.Include(w => w.Start).OrderByDescending(w => w.Start); var workoutList = await _repository.GetList(new WorkoutsSortedByDateWithPagingSpecification(pageIndex, _pageSize)) .ConfigureAwait(false); //var workoutList = await _repository.GetList(w => w.Start, true, _pageSize, pageIndex) var totalCount = await _repository.GetCount() .ConfigureAwait(false); Workouts = new ListWithPaging <WorkoutViewModel>(totalCount, pageIndex, _pageSize, nameof(pageNo)); foreach (var item in workoutList) { Workouts.Add(_mapper.Map <WorkoutViewModel>(item)); } }
/// <summary> /// Creates an authorize URL. /// </summary> /// <param name="request">The request.</param> /// <param name="clientId">The client identifier.</param> /// <param name="responseType">The response type.</param> /// <param name="scope">The scope.</param> /// <param name="redirectUri">The redirect URI.</param> /// <param name="state">The state.</param> /// <param name="nonce">The nonce.</param> /// <param name="loginHint">The login hint.</param> /// <param name="acrValues">The acr values.</param> /// <param name="prompt">The prompt.</param> /// <param name="responseMode">The response mode.</param> /// <param name="codeChallenge">The code challenge.</param> /// <param name="codeChallengeMethod">The code challenge method.</param> /// <param name="display">The display option.</param> /// <param name="maxAge">The max age.</param> /// <param name="uiLocales">The ui locales.</param> /// <param name="idTokenHint">The id_token hint.</param> /// <param name="extra">Extra parameters.</param> /// <returns></returns> public static string CreateAuthorizeUrl(this RequestUrl request, string clientId, string responseType, string scope = null, string redirectUri = null, string state = null, string nonce = null, string loginHint = null, string acrValues = null, string prompt = null, string responseMode = null, string codeChallenge = null, string codeChallengeMethod = null, string display = null, int?maxAge = null, string uiLocales = null, string idTokenHint = null, object extra = null) { var values = new Dictionary <string, string> { { OidcConstants.AuthorizeRequest.ClientId, clientId }, { OidcConstants.AuthorizeRequest.ResponseType, responseType } }; values.AddOptional(OidcConstants.AuthorizeRequest.Scope, scope); values.AddOptional(OidcConstants.AuthorizeRequest.RedirectUri, redirectUri); values.AddOptional(OidcConstants.AuthorizeRequest.State, state); values.AddOptional(OidcConstants.AuthorizeRequest.Nonce, nonce); values.AddOptional(OidcConstants.AuthorizeRequest.LoginHint, loginHint); values.AddOptional(OidcConstants.AuthorizeRequest.AcrValues, acrValues); values.AddOptional(OidcConstants.AuthorizeRequest.Prompt, prompt); values.AddOptional(OidcConstants.AuthorizeRequest.ResponseMode, responseMode); values.AddOptional(OidcConstants.AuthorizeRequest.CodeChallenge, codeChallenge); values.AddOptional(OidcConstants.AuthorizeRequest.CodeChallengeMethod, codeChallengeMethod); values.AddOptional(OidcConstants.AuthorizeRequest.Display, display); values.AddOptional(OidcConstants.AuthorizeRequest.MaxAge, maxAge?.ToString()); values.AddOptional(OidcConstants.AuthorizeRequest.UiLocales, uiLocales); values.AddOptional(OidcConstants.AuthorizeRequest.IdTokenHint, idTokenHint); return(request.Create(ValuesHelper.Merge(values, ValuesHelper.ObjectToDictionary(extra)))); }
/// <summary> /// Creates an authorize URL. /// </summary> /// <param name="request">The request.</param> /// <param name="values">The values (either using a string Dictionary or an object's properties).</param> /// <returns></returns> public static string Create(this RequestUrl request, object values) { return(request.Create(ValuesHelper.ObjectToDictionary(values))); }
public IEnumerable <string> Get() { var result = ValuesHelper.ReadFile(); return(new string[] { "Is OpenShift Working", "Yes!!! It seems to be working...", result }); }
/// <summary> /// Requests a token using a custom request /// </summary> /// <param name="client">The client.</param> /// <param name="values">The values.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <returns></returns> public static Task <TokenResponse> RequestCustomAsync(this TokenClient client, object values, CancellationToken cancellationToken = default(CancellationToken)) { return(client.RequestAsync(client.Merge(ValuesHelper.ObjectToDictionary(values)), cancellationToken)); }
public async Task OnGet(int?pageNo, string sortBy, bool?descending) { Expression <Func <WorkoutInterval, object> > sortSelector; switch (sortBy) { case DistanceSortKey: { sortSelector = i => i.Distance; break; } case DurationSortKey: { sortSelector = i => i.Duration; break; } case StrokeCountSortKey: { sortSelector = i => i.StrokeCount; break; } case PaceSortKey: { sortSelector = i => i.Pace; break; } case SwolfSortKey: { sortSelector = i => i.Swolf; break; } default: { sortSelector = i => i.Workout.WorkoutDate; break; } } var newSortOrder = string.IsNullOrWhiteSpace(sortBy) ? DateSortKey : sortBy; var sortDescending = descending ?? true; var pageIndex = ValuesHelper.GetPageIndex(pageNo); var intervals = await _intervalRepository.GetList(new SortedIntervalsByTypeSpecification(SelectedIntervalType, sortSelector, sortDescending, pageIndex, _pageSize)) //var intervals = await _intervalRepository.GetList( // q => q // .Where(i => i.WorkoutIntervalTypeId == SelectedIntervalType) // .Include(i => i.WorkoutIntervalType) // .Include(i => i.Workout), // _pageSize, pageIndex, sortSelector, sortDescending) .ConfigureAwait(false); //var intervals = await _intervalRepository.GetList(i => i.WorkoutIntervalTypeId == SelectedIntervalType, sortSelector, sortDescending, _pageSize, pageIndex, i => i.WorkoutIntervalType, i => i.Workout) var totalCount = await _intervalRepository.GetCount(new IntervalsByTypeSpecification(SelectedIntervalType)) //var totalCount = await _intervalRepository.GetCount(i => i.WorkoutIntervalTypeId == SelectedIntervalType) .ConfigureAwait(false); var sortKeys = new Dictionary <string, string> { { DateFieldName, DateSortKey }, { DistanceFieldName, DistanceSortKey }, { DurationFieldName, DurationSortKey }, { StrokeCountFieldName, StrokeCountSortKey }, { PaceFieldName, PaceSortKey }, { SwolfFieldName, SwolfSortKey } }; Intervals = new ListWithPagingAndSorting <WorkoutIntervalViewModel>(totalCount, pageIndex, _pageSize, nameof(pageNo), nameof(sortBy), nameof(descending), newSortOrder, sortDescending, sortKeys); foreach (var interval in intervals) { var displayItem = _mapper.Map <WorkoutIntervalViewModel>(interval); displayItem.WorkoutName = interval.Workout.Name; displayItem.WorkoutDate = interval.Workout.WorkoutDate; Intervals.Add(displayItem); } Intervals.FirstPageRouteValues.Add(nameof(SelectedIntervalType), SelectedIntervalType.ToStringInvariant()); Intervals.LastPageRouteValues.Add(nameof(SelectedIntervalType), SelectedIntervalType.ToStringInvariant()); Intervals.PrevPageRouteValues.Add(nameof(SelectedIntervalType), SelectedIntervalType.ToStringInvariant()); Intervals.NextPageRouteValues.Add(nameof(SelectedIntervalType), SelectedIntervalType.ToStringInvariant()); foreach (var routeValues in Intervals.SortRouteValues) { routeValues.Value.Add(nameof(SelectedIntervalType), SelectedIntervalType.ToStringInvariant()); } var intervalTypes = await _intervalTypeRepository.GetList() .ConfigureAwait(false); WorkoutIntervalTypeSelectList = new SelectList(intervalTypes, "Id", "Name"); }