public override UploadResult Upload(Stream stream, string fileName) { if (string.IsNullOrEmpty(Settings.URL)) { throw new Exception("Plik Host is empty."); } NameValueCollection requestHeaders = new NameValueCollection(); requestHeaders["X-PlikToken"] = Settings.APIKey; UploadMetadataRequest metaDataReq = new UploadMetadataRequest(); metaDataReq.Files = new UploadMetadataRequestFile0(); metaDataReq.Files.File0 = new UploadMetadataRequestFile(); metaDataReq.Files.File0.FileName = fileName; metaDataReq.Files.File0.FileType = RequestHelpers.GetMimeType(fileName); metaDataReq.Files.File0.FileSize = Convert.ToInt32(stream.Length); metaDataReq.Removable = Settings.Removable; metaDataReq.OneShot = Settings.OneShot; if (Settings.TTLUnit != 3) // everything except the expire time -1 { metaDataReq.Ttl = Convert.ToInt32(GetMultiplyIndex(2, Settings.TTLUnit) * Settings.TTL * 60); } else { metaDataReq.Ttl = -1; } if (Settings.HasComment) { metaDataReq.Comment = Settings.Comment; } if (Settings.IsSecured) { metaDataReq.Login = Settings.Login; metaDataReq.Password = Settings.Password; } string metaDataResp = SendRequest(HttpMethod.POST, Settings.URL + "/upload", JsonConvert.SerializeObject(metaDataReq), headers: requestHeaders); UploadMetadataResponse metaData = JsonConvert.DeserializeObject <UploadMetadataResponse>(metaDataResp); requestHeaders["x-uploadtoken"] = metaData.uploadToken; string url = $"{Settings.URL}/file/{metaData.id}/{metaData.files.First().Value.id}/{fileName}"; UploadResult FileDatReq = SendRequestFile(url, stream, fileName, "file", headers: requestHeaders); return(ConvertResult(metaData, FileDatReq)); }
public ActionResult SendPlaystateCommand( [FromRoute, Required] string sessionId, [FromRoute, Required] PlaystateCommand command, [FromQuery] long?seekPositionTicks, [FromQuery] string?controllingUserId) { _sessionManager.SendPlaystateCommand( RequestHelpers.GetSession(_sessionManager, _authContext, Request).Id, sessionId, new PlaystateRequest() { Command = command, ControllingUserId = controllingUserId, SeekPositionTicks = seekPositionTicks, }, CancellationToken.None); return(NoContent()); }
/// <summary> /// Tries to parse a <see cref="B2Error"/> from the given response. /// </summary> /// <param name="res">The response that contains an error.</param> /// <returns> /// The parse result, or null if the response is successful or cannot be parsed. /// </returns> /// <exception cref="IOException">If the response body cannot be read.</exception> private static B2Error ParseB2Error(HttpWebResponse res) { if (RequestHelpers.IsSuccessStatusCode(res.StatusCode)) { return(null); } try { string body = RequestHelpers.ResponseToString(res); DebugHelper.WriteLine($"B2 uploader: ParseB2Error() got: {body}"); B2Error err = JsonConvert.DeserializeObject <B2Error>(body); return(err); } catch (JsonException) { return(null); } }
public async Task <ActionResult> UpdateUserPassword( [FromRoute, Required] Guid userId, [FromBody, Required] UpdateUserPassword request) { if (!await RequestHelpers.AssertCanUpdateUser(_authContext, HttpContext.Request, userId, true).ConfigureAwait(false)) { return(StatusCode(StatusCodes.Status403Forbidden, "User is not allowed to update the password.")); } var user = _userManager.GetUserById(userId); if (user == null) { return(NotFound("User not found")); } if (request.ResetPassword) { await _userManager.ResetPassword(user).ConfigureAwait(false); } else { var success = await _userManager.AuthenticateUser( user.Username, request.CurrentPw, request.CurrentPw, HttpContext.GetNormalizedRemoteIp().ToString(), false).ConfigureAwait(false); if (success == null) { return(StatusCode(StatusCodes.Status403Forbidden, "Invalid user or password entered.")); } await _userManager.ChangePassword(user, request.NewPw).ConfigureAwait(false); var currentToken = (await _authContext.GetAuthorizationInfo(Request).ConfigureAwait(false)).Token; await _sessionManager.RevokeUserTokens(user.Id, currentToken).ConfigureAwait(false); } return(NoContent()); }
/// <inheritdoc/> public async Task <List <Rule> > GetRulesAsync() { if (_currentChallenge == 0) { await RenewChallengeAsync(); } byte[] response = await SendRequestAsync( RequestHelpers.PrepareAS2_GENERIC_Request(RequestHeaders.A2S_RULES, _currentChallenge)); if (response.Length > 0) { return(DataResolutionUtils.ExtractListData <Rule>(response)); } else { throw new InvalidOperationException("Server did not response the query"); } }
public void Get_Residency_ById_And_Courses_WithoutGenericHelper() { //arrange var filterLambdaOperatorDescriptor = GetFilterExpressionDescriptor <ResidencyModel> ( GetResidencyByIdFilterBody(2), "q" ); IMapper mapper = serviceProvider.GetRequiredService <IMapper>(); IEnrollmentRepository repository = serviceProvider.GetRequiredService <IEnrollmentRepository>(); //act var expression = mapper.MapToOperator(filterLambdaOperatorDescriptor).Build(); var selectAndExpand = new Common.Configuration.ExpansionDescriptors.SelectExpandDefinitionDescriptor { ExpandedItems = new List <Common.Configuration.ExpansionDescriptors.SelectExpandItemDescriptor> { new Common.Configuration.ExpansionDescriptors.SelectExpandItemDescriptor { MemberName = "StatesLivedIn" } } }; var entity = (ResidencyModel)RequestHelpers.GetEntity ( new Business.Requests.GetEntityRequest { Filter = filterLambdaOperatorDescriptor, SelectExpandDefinition = selectAndExpand, ModelType = typeof(ResidencyModel).AssemblyQualifiedName, DataType = typeof(Residency).AssemblyQualifiedName }, repository, mapper ).Result.Entity; //assert AssertFilterStringIsCorrect(expression, "q => (q.UserId == 2)"); Assert.Equal(2, entity.StatesLivedIn.Count); }
public void GraphqlBatchUpdateEntities(EntityFactory entityFactory, int numEntities) { var entity = entityFactory.Construct(); var entityProperties = entity.GetType().GetProperties(); if (entityProperties.Any(x => x.PropertyType.IsEnum) || entity.HasFile) { throw new SkipException("Batch update is currently not supported on entities with enum or file"); } var entityList = entityFactory.ConstructAndSave(_output, numEntities); //setup the rest client var client = new RestClient { BaseUrl = new Uri($"{_configure.BaseUrl}/api/graphql") }; //setup the request var request = new RestRequest { Method = Method.POST, RequestFormat = DataFormat.Json }; //get the authorization token and adds the token to the request var loginToken = new LoginToken(_configure.BaseUrl, _configure.SuperUsername, _configure.SuperPassword); var authorizationToken = $"{loginToken.TokenType} {loginToken.AccessToken}"; request.AddHeader("Authorization", authorizationToken); request.AddHeader("Content-Type", "application/json"); request.AddHeader("Accept", "*\\*"); // form the query to update the entity var updateQuery = QueryBuilder.BatchUpdateEntityQueryBuilder(entityList); request.AddParameter("text/json", updateQuery, ParameterType.RequestBody); // mass update all entities in the list in a single request and check status code is ok RequestHelpers.ValidateResponse(client, Method.POST, request, HttpStatusCode.OK); }
public async Task <ActionResult> SendPlaystateCommand( [FromRoute, Required] string sessionId, [FromRoute, Required] PlaystateCommand command, [FromQuery] long?seekPositionTicks, [FromQuery] string?controllingUserId) { await _sessionManager.SendPlaystateCommand( await RequestHelpers.GetSessionId(_sessionManager, _authContext, Request).ConfigureAwait(false), sessionId, new PlaystateRequest() { Command = command, ControllingUserId = controllingUserId, SeekPositionTicks = seekPositionTicks, }, CancellationToken.None) .ConfigureAwait(false); return(NoContent()); }
public async Task <ActionResult> UpdateUser( [FromRoute, Required] Guid userId, [FromBody, Required] UserDto updateUser) { if (!await RequestHelpers.AssertCanUpdateUser(_authContext, HttpContext.Request, userId, false).ConfigureAwait(false)) { return(StatusCode(StatusCodes.Status403Forbidden, "User update not allowed.")); } var user = _userManager.GetUserById(userId); if (!string.Equals(user.Username, updateUser.Name, StringComparison.Ordinal)) { await _userManager.RenameUser(user, updateUser.Name).ConfigureAwait(false); } await _userManager.UpdateConfigurationAsync(user.Id, updateUser.Configuration).ConfigureAwait(false); return(NoContent()); }
public ActionResult SysAdmin(bool?isPwdReset) { if (isPwdReset.HasValue && isPwdReset.Value) { ViewData[ViewConstants.REDIRECT_URL_KEY] = UrlsConstants.RESET_PASSWORD_URL; } var sysUser = MasterLocator.UserService.GetById(Context.UserId); ViewData[ViewConstants.AZURE_PICTURE_URL] = PictureService.GetPicturesRelativeAddress(); ViewData[ViewConstants.DEMO_AZURE_PICTURE_URL] = PictureService.GeDemoPicturesRelativeAddress(); PrepareJsonData(SysAdminViewData.Create(sysUser), ViewConstants.CURRENT_PERSON); ViewData[ViewConstants.SERVER_TIME] = Context.NowSchoolTime.ToString(DATE_TIME_FORMAT); var ip = RequestHelpers.GetClientIpAddress(Request); MasterLocator.UserTrackingService.IdentifySysAdmin(sysUser.Login, "", "", null, ip); ViewData[ViewConstants.ROLE_NAME] = CoreRoles.SUPER_ADMIN_ROLE.LoweredName; ViewData[ViewConstants.ASSESSMENT_APLICATION_ID] = MasterLocator.ApplicationService.GetAssessmentId(); return(View()); }
public void Write(string accion, string mensaje) { var _lei = new LogEventInfo(LogLevel.Info, _logger.Name, _logger.Name); _lei.Properties.Add("accion", accion); if (_application.IsAuthenticated()) { var personaId = _application.GetCurrentUser().PersonaId; if (personaId.HasValue) { var persona = _iPersonaService.Get((int)personaId); _lei.Properties.Add("indentificacion", persona.Identificacion); } else { _lei.Properties.Add("indentificacion", "AN"); } } else { _lei.Properties.Add("indentificacion", "AN"); } //Almacenar IP if (HttpContext.Current != null && HttpContext.Current.Request != null) { string ipAddress = RequestHelpers.GetClientIpAddress(new HttpRequestWrapper(HttpContext.Current.Request)); _lei.Properties.Add("ip", ipAddress); } else { _lei.Properties.Add("ip", string.Empty); } _lei.Message = mensaje; _logger.Log(_lei); }
public static void Main(string[] args) { bool tracingDisabled = args.Any(arg => arg.Equals("TracingDisabled", StringComparison.OrdinalIgnoreCase)); Console.WriteLine($"TracingDisabled {tracingDisabled}"); string port = args.FirstOrDefault(arg => arg.StartsWith("Port="))?.Split('=')[1] ?? "9000"; Console.WriteLine($"Port {port}"); using (var listener = StartHttpListenerWithPortResilience(port)) { Console.WriteLine(); Console.WriteLine($"Starting HTTP listener at {Url}"); // send http requests using WebClient Console.WriteLine(); Console.WriteLine("Sending request with WebClient."); using (Tracer.Instance.StartActive("RequestHelpers.SendWebClientRequests")) { RequestHelpers.SendWebClientRequests(tracingDisabled, Url, RequestContent); } Console.WriteLine("Sending request with WebRequest."); using (Tracer.Instance.StartActive("RequestHelpers.SendWebRequestRequests")) { RequestHelpers.SendWebRequestRequests(tracingDisabled, Url, RequestContent); } Console.WriteLine(); Console.WriteLine("Stopping HTTP listener."); listener.Stop(); } // Force process to end, otherwise the background listener thread lives forever in .NET Core. // Apparently listener.GetContext() doesn't throw an exception if listener.Stop() is called, // like it does in .NET Framework. Environment.Exit(0); }
public ActionResult DisplayContent( [FromRoute, Required] string?sessionId, [FromQuery, Required] string?itemType, [FromQuery, Required] string?itemId, [FromQuery, Required] string?itemName) { var command = new BrowseRequest { ItemId = itemId, ItemName = itemName, ItemType = itemType }; _sessionManager.SendBrowseCommand( RequestHelpers.GetSession(_sessionManager, _authContext, Request).Id, sessionId, command, CancellationToken.None); return(NoContent()); }
public void MissingXSRFTokenValidCookiesUnauthTest() { // get a paired client and xsrf token var clientxsrf = ClientXsrf.GetValidClientAndxsrfTokenPair(_configure); // extract the client var client = clientxsrf.client; // extract the xsrf token var xsrfToken = clientxsrf.xsrfToken; // set the uri for the authorised api request client.BaseUrl = new Uri($"{_configure.BaseUrl}/api/account/me"); //setup the request var request = RequestHelpers.BasicPostRequest(); // we don't expect out result to be valid since we have not attatched a valid // xsrf token as a header, although we do have valid cookies ResponseHelpers.CheckResponse(client, request, expectValid: false); }
public ActionResult Play( [FromRoute, Required] string sessionId, [FromRoute, Required] PlayCommand command, [FromQuery] Guid[] itemIds, [FromQuery] long?startPositionTicks) { var playRequest = new PlayRequest { ItemIds = itemIds, StartPositionTicks = startPositionTicks, PlayCommand = command }; _sessionManager.SendPlayCommand( RequestHelpers.GetSession(_sessionManager, _authContext, Request).Id, sessionId, playRequest, CancellationToken.None); return(NoContent()); }
private void PrepareStudentJsonData() { Trace.Assert(Context.PersonId.HasValue); var startupData = SchoolLocator.SchoolService.GetStartupData(); var district = PrepareCommonViewDataForSchoolPerson(startupData); var person = startupData.Person; var personView = PersonInfoViewData.Create(person); ProcessFirstLogin(person); ProcessActive(person, personView); PrepareJsonData(personView, ViewConstants.CURRENT_PERSON); var dayTypes = SchoolLocator.DayTypeService.GetDayTypes(startupData.Classes.SelectMany(x => x.ClassPeriods, (a, b) => b.DayTypeRef).ToList()); var classesVD = ClassComplexViewData.Create(startupData.Classes, startupData.Rooms, dayTypes).ToList(); PrepareJsonData(classesVD, ViewConstants.CLASSES); var ip = RequestHelpers.GetClientIpAddress(Request); MasterLocator.UserTrackingService.IdentifyStudent(Context.Login, person.FirstName, person.LastName, district.Name, "", person.FirstLoginDate, Context.DistrictTimeZone, ip, Context.SCEnabled); }
public ActionResult SendFullGeneralCommand( [FromRoute, Required] string?sessionId, [FromBody, Required] GeneralCommand command) { var currentSession = RequestHelpers.GetSession(_sessionManager, _authContext, Request); if (command == null) { throw new ArgumentException("Request body may not be null"); } command.ControllingUserId = currentSession.UserId; _sessionManager.SendGeneralCommand( currentSession.Id, sessionId, command, CancellationToken.None); return(NoContent()); }
public ActionResult UpdateInfo(Guid developerId, string name, string websiteLink, string email) { var user = MasterLocator.UserService.GetByLogin(email); if (user != null && user.Id != Context.UserId) { return(Json(new ChalkableException("User email already exists"))); } var res = MasterLocator.DeveloperService.Edit(developerId, name, email, websiteLink, null); MasterLocator.UserTrackingService.ChangedEmail(Context.Login, email); if (Context.Role.LoweredName == CoreRoles.DEVELOPER_ROLE.LoweredName) { var timeZoneId = Context.DistrictTimeZone; var ip = RequestHelpers.GetClientIpAddress(Request); MasterLocator.UserTrackingService.IdentifyDeveloper(res.Email, res.DisplayName, String.IsNullOrEmpty(timeZoneId) ? DateTime.UtcNow : DateTime.UtcNow.ConvertFromUtc(timeZoneId), timeZoneId, ip); } return(Json(DeveloperViewData.Create(res))); }
public ActionResult SendSystemCommand( [FromRoute, Required] string?sessionId, [FromRoute, Required] string?command) { var name = command; if (Enum.TryParse(name, true, out GeneralCommandType commandType)) { name = commandType.ToString(); } var currentSession = RequestHelpers.GetSession(_sessionManager, _authContext, Request); var generalCommand = new GeneralCommand { Name = name, ControllingUserId = currentSession.UserId }; _sessionManager.SendGeneralCommand(currentSession.Id, sessionId, generalCommand, CancellationToken.None); return(NoContent()); }
public async Task <ActionResult> DisplayContent( [FromRoute, Required] string sessionId, [FromQuery, Required] string itemType, [FromQuery, Required] string itemId, [FromQuery, Required] string itemName) { var command = new BrowseRequest { ItemId = itemId, ItemName = itemName, ItemType = itemType }; await _sessionManager.SendBrowseCommand( await RequestHelpers.GetSessionId(_sessionManager, _authContext, Request).ConfigureAwait(false), sessionId, command, CancellationToken.None) .ConfigureAwait(false); return(NoContent()); }
public void Select_Residencies_In_Ascending_Order_As_ResidencyModel_Type_With_Courses() { //arrange var selectorLambdaOperatorDescriptor = GetExpressionDescriptor <IQueryable <ResidencyModel>, IQueryable <ResidencyModel> > ( GetResidenciesBodyOrderByDriversLicenseNumber(), "q" ); IMapper mapper = serviceProvider.GetRequiredService <IMapper>(); IEnrollmentRepository repository = serviceProvider.GetRequiredService <IEnrollmentRepository>(); //act var expression = mapper.MapToOperator(selectorLambdaOperatorDescriptor).Build(); var selectAndExpand = new Common.Configuration.ExpansionDescriptors.SelectExpandDefinitionDescriptor { ExpandedItems = new List <Common.Configuration.ExpansionDescriptors.SelectExpandItemDescriptor> { new Common.Configuration.ExpansionDescriptors.SelectExpandItemDescriptor { MemberName = "StatesLivedIn" } } }; var list = RequestHelpers.GetList <ResidencyModel, Residency, IQueryable <ResidencyModel>, IQueryable <Residency> > ( new Business.Requests.GetTypedListRequest { Selector = selectorLambdaOperatorDescriptor, SelectExpandDefinition = selectAndExpand }, repository, mapper ).Result.List.Cast <ResidencyModel>().ToList(); //assert AssertFilterStringIsCorrect(expression, "q => Convert(q.OrderBy(d => d.DriversLicenseNumber))"); Assert.Equal(2, list.Count); Assert.True(list.All(d => d.StatesLivedIn.Any())); }
private string Push(string pushType, string valueType, string value, string title) { NameValueCollection headers = RequestHelpers.CreateAuthenticationHeader(Config.UserAPIKey, ""); Dictionary <string, string> args = new Dictionary <string, string>(); args.Add("device_iden", Config.CurrentDevice.Key); args.Add("type", pushType); args.Add("title", title); args.Add(valueType, value); if (valueType != "body") { if (pushType == "link") { args.Add("body", value); } else { args.Add("body", "Sent via ShareX"); } } string response = SendRequestMultiPart(apiSendPushURL, args, headers); if (response == null) { return(null); } PushbulletResponsePush push = JsonConvert.DeserializeObject <PushbulletResponsePush>(response); if (push != null) { return(wwwPushesURL + "?push_iden=" + push.iden); } return(null); }
public HttpResponseMessage Carregar() { HttpResponseMessage result = null; NameValueCollection data = HttpUtility.ParseQueryString(Request.RequestUri.Query); // Parametros da pesquisa DateTime?dataEntrega = RequestHelpers.ObterDataOuNulo(data["Data"]); if (!dataEntrega.HasValue) { dataEntrega = DateTime.Now; } //List<Entrega> entregas = _repoEntrega.PesquisarEntregas(null, null, null, dataEntrega); //dynamic lst = entregas.Select(x => new //{ // id = x.idEntrega, // title = x.Projeto.sigla, // description = x.descricaoAtividade, // url = "#", // Class = "event-warning", // start = (x.dataEntregaPrevista.Value - new DateTime(1969, 12, 31)).TotalMilliseconds, // end = (x.dataEntregaPrevista.Value - new DateTime(1969, 12, 31)).TotalMilliseconds //}).ToList(); JObject obj = new JObject(); //obj.Add("entregas", JsonConvert.SerializeObject(entregas)); //obj.Add("calendar", JsonConvert.SerializeObject(lst)); result = Request.CreateResponse(HttpStatusCode.OK, obj); return(result); }
public async Task <ActionResult> OnPlaybackProgress( [FromRoute, Required] Guid userId, [FromRoute, Required] Guid itemId, [FromQuery] string?mediaSourceId, [FromQuery] long?positionTicks, [FromQuery] int?audioStreamIndex, [FromQuery] int?subtitleStreamIndex, [FromQuery] int?volumeLevel, [FromQuery] PlayMethod?playMethod, [FromQuery] string?liveStreamId, [FromQuery] string?playSessionId, [FromQuery] RepeatMode?repeatMode, [FromQuery] bool isPaused = false, [FromQuery] bool isMuted = false) { var playbackProgressInfo = new PlaybackProgressInfo { ItemId = itemId, PositionTicks = positionTicks, IsMuted = isMuted, IsPaused = isPaused, MediaSourceId = mediaSourceId, AudioStreamIndex = audioStreamIndex, SubtitleStreamIndex = subtitleStreamIndex, VolumeLevel = volumeLevel, PlayMethod = playMethod ?? PlayMethod.Transcode, PlaySessionId = playSessionId, LiveStreamId = liveStreamId, RepeatMode = repeatMode ?? RepeatMode.RepeatNone }; playbackProgressInfo.PlayMethod = ValidatePlayMethod(playbackProgressInfo.PlayMethod, playbackProgressInfo.PlaySessionId); playbackProgressInfo.SessionId = await RequestHelpers.GetSessionId(_sessionManager, _authContext, Request).ConfigureAwait(false); await _sessionManager.OnPlaybackProgress(playbackProgressInfo).ConfigureAwait(false); return(NoContent()); }
public void GetPlayers_ShouldPopulateCorrectPlayers() { (byte[] playersPacket, object responseObject) = ResponseHelper.GetValidResponse(ResponseHelper.GetPlayers); var expectedObject = (List <Player>)responseObject; byte[] challengePacket = RequestHelpers.PrepareAS2_RENEW_CHALLENGE_Request(); // Both requests will be executed on AS2_PLAYER since thats how you refresh challenges. byte[][] requestPackets = new byte[][] { challengePacket, challengePacket }; // First response is the Challenge renewal response and the second byte[][] responsePackets = new byte[][] { challengePacket, playersPacket }; Mock <IUdpClient> udpClientMock = SetupReceiveResponse(responsePackets); SetupRequestCompare(requestPackets, udpClientMock); // Ayylmao it looks ugly as hell but we will improve it later on. using (var sq = new ServerQuery(udpClientMock.Object, _localIpEndpoint)) { Assert.Equal(JsonConvert.SerializeObject(expectedObject), JsonConvert.SerializeObject(sq.GetPlayers())); } }
public ActionResult PostCapabilities( [FromQuery] string?id, [FromQuery, ModelBinder(typeof(CommaDelimitedArrayModelBinder))] string[] playableMediaTypes, [FromQuery, ModelBinder(typeof(CommaDelimitedArrayModelBinder))] GeneralCommandType[] supportedCommands, [FromQuery] bool supportsMediaControl = false, [FromQuery] bool supportsSync = false, [FromQuery] bool supportsPersistentIdentifier = true) { if (string.IsNullOrWhiteSpace(id)) { id = RequestHelpers.GetSession(_sessionManager, _authContext, Request).Id; } _sessionManager.ReportCapabilities(id, new ClientCapabilities { PlayableMediaTypes = playableMediaTypes, SupportedCommands = supportedCommands, SupportsMediaControl = supportsMediaControl, SupportsSync = supportsSync, SupportsPersistentIdentifier = supportsPersistentIdentifier }); return(NoContent()); }
public ActionResult PostCapabilities( [FromQuery, Required] string?id, [FromQuery] string?playableMediaTypes, [FromQuery] string?supportedCommands, [FromQuery] bool supportsMediaControl = false, [FromQuery] bool supportsSync = false, [FromQuery] bool supportsPersistentIdentifier = true) { if (string.IsNullOrWhiteSpace(id)) { id = RequestHelpers.GetSession(_sessionManager, _authContext, Request).Id; } _sessionManager.ReportCapabilities(id, new ClientCapabilities { PlayableMediaTypes = RequestHelpers.Split(playableMediaTypes, ',', true), SupportedCommands = RequestHelpers.Split(supportedCommands, ',', true), SupportsMediaControl = supportsMediaControl, SupportsSync = supportsSync, SupportsPersistentIdentifier = supportsPersistentIdentifier }); return(NoContent()); }
public static void Main(string[] args) { bool tracingDisabled = args.Any(arg => arg.Equals("TracingDisabled", StringComparison.OrdinalIgnoreCase)); Console.WriteLine($"TracingDisabled {tracingDisabled}"); string port = args.FirstOrDefault(arg => arg.StartsWith("Port="))?.Split('=')[1] ?? "9000"; Console.WriteLine($"Port {port}"); using (var server = WebServer.Start(port, out var url)) { server.RequestHandler = HandleHttpRequests; Console.WriteLine(); Console.WriteLine($"Starting HTTP listener at {url}"); // send http requests using WebClient Console.WriteLine(); Console.WriteLine("Sending request with WebClient."); using (Tracer.Instance.StartActive("RequestHelpers.SendWebClientRequests")) { RequestHelpers.SendWebClientRequests(tracingDisabled, url, RequestContent); } Console.WriteLine("Sending request with WebRequest."); using (Tracer.Instance.StartActive("RequestHelpers.SendWebRequestRequests")) { RequestHelpers.SendWebRequestRequests(tracingDisabled, url, RequestContent); } Console.WriteLine(); Console.WriteLine("Stopping HTTP listener."); } }
public EventList get(string sport, DateTime date) { string jsonStr, url = ""; EventList eventResult = null; NameValueCollection queryParameters = new NameValueCollection(); using (var client = new GZipWebClient(_apiKey, _userAgentName, true)) { if (_alternateDomain == null) { url = "https://erikberg.com/events.json"; } else { url = "https://" + _alternateDomain + "/events.json"; } if (sport != null) { queryParameters.Add("sport", sport); } if (date != null) { queryParameters.Add("date", date.ToString("yyyyMMdd")); } if (queryParameters.Count > 0) { url += RequestHelpers.ToQueryString(queryParameters); } jsonStr = client.DownloadString(url); eventResult = JsonConvert.DeserializeObject <EventList>(jsonStr); return(eventResult); } }
public ActionResult Login(LoginViewModel model, string returnUrl) { if (!ModelState.IsValid) { return(View(model)); } var result = _accountRepo.Login(model, RequestHelpers.RequestIPAddress()); var valid = _accountRepo.CheckValidForTransaction(result.UserId, RequestHelpers.RequestIPAddress()); if (!valid) { return(RedirectToAction("IpBlocked", "Account")); } if (result != null) { SetUserSession(result); return(RedirectToLocal(returnUrl)); } else { ModelState.AddModelError("", "Incorrect Username or Password"); return(View(model)); } }