public async Task <IActionResult> SubmitFeatureRequest([FromForm] FeatureRequest featureRequest) { featureRequest.SAP1EMUVersion = GetType().Assembly.GetName().Version.ToString(); StringBuilder body = new StringBuilder(); body.AppendLine("**SAP1EMU Version**"); body.AppendLine($"v{featureRequest.SAP1EMUVersion}"); body.AppendLine(); body.AppendLine("**Description**"); body.AppendLine(featureRequest.Description); try { Issue createdIssue = await CreateGithubIssue(featureRequest.Title, body.ToString(), featureTag); return(Ok(createdIssue)); } catch (NotFoundException) { return(NotFound()); } catch (AuthorizationException) { return(Unauthorized()); } }
public async Task GetAll_ReturnsExpectedFeatures() { var client = fixture.CreateClient(); var testFeature = new FeatureRequest { Name = nameof(TestFeature), Enabled = true }; var testFeature2 = new FeatureRequest { Name = nameof(TestFeature2), Enabled = true }; await SetValueViaApiAsync(testFeature); await SetValueViaApiAsync(testFeature2); var uiSettings = fixture.Services.GetRequiredService <FeatureFlagUISettings>(); var response = await client.GetAsync(uiSettings.ApiGetAllPath); response.EnsureSuccessStatusCode(); var features = (await response.Content.ReadAsJson <IEnumerable <FeatureResponse> >()).ToList(); Assert.Equal(2, features.Count); Assert.All(features, feature => Assert.True(feature.Enabled)); }
protected override void Unpack(Unpacker unpacker) { base.Unpack(unpacker); FeatureId = unpacker.UnpackUshort(); RequestId = unpacker.UnpackUshort(); var size = unpacker.UnpackUshort(); var feature = Feature.GetFeature(FeatureId); if (feature == null) { Log.Warn($"Unkown Feature {FeatureId} in {GetType().Name}."); unpacker.UnpackByteArray(size); } else { Request = feature.RestoreRequest(unpacker, size, RequestId); if (Request == null) { Log.Warn($"Unkown RequestId {RequestId} for Feature {FeatureId} in {GetType().Name}."); unpacker.UnpackByteArray(size); } } }
public ActionResult SaveFeatureRequest(FeatureRequest featureRequest) { featureRequestRepository.Save(featureRequest); TempData["message"] = "The feature request was saved successfully"; return(View("Index", featureRequestRepository.FeatureRequests.OrderBy(x => x.Status).ThenBy(x => x.CreateDate))); }
public void SetFeatureRequest(FeatureRequest request) { Request = request; FeatureId = request.FeatureId; RequestId = request.RequestId; }
public override StringMangleStackTop?Emit(IStringMangleContext context) { var emitter = context.Emitter; var fr = new FeatureRequest(Context, emitter); using (var r = fr.Enter(context.SourceMethod)) if (r != null) { ValueDemangler cdm; do { cdm = _demanglers.RandomElementOrDefault(Mangler.Rng); } while (fr.IsOnStack(cdm.Method.Method)); var part = context.Pieces.Dequeue(); using (emitter.UseTempLocal(cdm.Method.Type.TypeMapping.Target.ToTypeSig(), out var instance)) { cdm.EmitNew(emitter, Mangler.Rng, instance); var mangledPart = cdm.Codec.Mangle(part.Value); Debug.Assert(Equals(cdm.Codec.Demangle(mangledPart), part.Value)); cdm.EmitCall(emitter, Mangler.Rng, instance, mangledPart); } return(StringMangleStackTop.String); } return(null); }
public void SetFeatureRequest(FeatureRequest request) { Request = request; FeatureId = request.FeatureId; RequestId = request.RequestId; _updateRequestTransaction = true; }
public ActionResult CreateFeatureRequest() { var newFeatureRequest = new FeatureRequest { RequestedBy = User.Identity.Name }; return(View("EditFeatureRequest", newFeatureRequest)); }
private async Task SetValueViaApiAsync(FeatureRequest featureRequest) { var client = fixture.CreateClient(); var uiSettings = fixture.Services.GetRequiredService <FeatureFlagUISettings>(); var response = await client.PostAsync( uiSettings.ApiSetPath, new StringContent(JsonConvert.SerializeObject(featureRequest)) ); response.EnsureSuccessStatusCode(); }
public void AddVoteDownRequestByUserForArticle(long userId, StreamType modelStreamType, long id) { var featureRequest = new FeatureRequest { UserId = userId, RssEntryId = id, StreamType = modelStreamType, Type = FeatureRequestType.VoteDown }; this.database.FeatureRequests.Add(featureRequest); this.database.SaveChanges(); }
//public override Task<FeatureReply> GetAll(FeatureRequest request, ServerCallContext context) //{ // //[1] 인-메모리 // //FeatureReply reply = new FeatureReply(); // //reply.Features.Add(new FeatureEntity { Id = 1, Title = "ASP.NET", Created = "1234" }); // //reply.Features.Add(new FeatureEntity { Id = 2, Title = "Blazor", Created = "1234" }); // //reply.Features.Add(new FeatureEntity { Id = 3, Title = "C#", Created = "1234" }); // //[2] 실제 데이터베이스 // FeatureReply reply = new FeatureReply(); // using (var ctx = new ApplicationDbContext()) // { // var features = ctx.Features.OrderBy(f => f.Id).ToList(); // foreach (var f in features) // { // reply.Features.Add(new FeatureEntity { Id = f.Id, Title = f.Title, Created = f.Created.ToString() }); // } // } // return Task.FromResult(reply); //} public override Task <FeatureReply> GetAll(FeatureRequest request, ServerCallContext context) { FeatureReply reply = new FeatureReply(); var features = dbContext.Features.OrderBy(f => f.Id).ToList(); foreach (var f in features) { reply.Features.Add(new FeatureEntity { Id = f.Id, Title = f.Title, Created = f.Created.ToString() }); } return(Task.FromResult(reply)); }
public bool FeatureRequestSave(FeatureRequest obj) { bool retVal = true; string procName = (obj.Id == 0 ? "dbo.OXO_FeatureRequest_New" : "dbo.OXO_FeatureRequest_Edit"); using (IDbConnection conn = DbHelper.GetDBConnection()) { try { var para = new DynamicParameters(); para.Add("@p_Programme_Id", obj.Programme_Id, dbType: DbType.Int32); para.Add("@p_Description", obj.Description, dbType: DbType.String, size: 500); para.Add("@p_Marketing_Description", obj.Marketing_Description, dbType: DbType.String, size: 500); para.Add("@p_Notes", obj.Notes, dbType: DbType.String, size: 2000); para.Add("@p_Feature_Group", obj.Feature_Group, dbType: DbType.String, size: 500); para.Add("@p_Decision", obj.Decision, dbType: DbType.String, size: 500); para.Add("@p_Created_By", obj.Created_By, dbType: DbType.String, size: 8); para.Add("@p_Created_On", obj.Created_On, dbType: DbType.DateTime); para.Add("@p_Updated_By", obj.Updated_By, dbType: DbType.String, size: 8); para.Add("@p_Last_Updated", obj.Last_Updated, dbType: DbType.DateTime); if (obj.Id == 0) { para.Add("@p_Id", dbType: DbType.Int32, direction: ParameterDirection.Output); } else { para.Add("@p_Id", obj.Id, dbType: DbType.Int32); } conn.Execute(procName, para, commandType: CommandType.StoredProcedure); if (obj.Id == 0) { obj.Id = para.Get <int>("@p_Id"); } } catch (Exception ex) { Log.Error(ex); throw; } } return(retVal); }
public async Task <IActionResult> Put(string featureId, [FromBody] FeatureRequest feature) { if (!IsValidTimeSpan(feature.Lifetime)) { return(BadRequest("lifetime could not be parsed")); } var response = await _featureService.UpdateFeature(featureId, (Feature)feature); if (response == null) { return(NotFound()); } return(Ok((FeatureResponse)response)); }
public async Task Set_SetsExpectedFeature(bool?expected) { var request = new FeatureRequest { Name = nameof(TestFeature2), Enabled = expected }; await SetValueViaApiAsync(request); var result = await GetFeatureFromApiAsync(nameof(TestFeature2)); Assert.Equal(expected, result.Enabled); Assert.Equal(nameof(TestFeature2), result.Name); Assert.Equal("Test feature 2 description.", result.Description); }
public async Task <IActionResult> Post([FromBody] FeatureRequest feature) { if (!IsValidTimeSpan(feature.Lifetime)) { return(BadRequest("lifetime could not be parsed")); } var newFeature = await _featureService.CreateFeature((Feature)feature); if (newFeature == null) { return(StatusCode((int)HttpStatusCode.Conflict)); } return(CreatedAtRoute("GetFeature", new { FeatureId = newFeature.Id }, (FeatureResponse)newFeature)); }
public void Emit(FeatureRequest request, int value) { ValueDemangler cdm; do { cdm = _demanglers.RandomElementOrDefault(Rng); } while (request.IsOnStack(cdm.Method.Method)); using (request.Emitter.UseTempLocal(cdm.Method.Type.TypeMapping.Target.ToTypeSig(), out var instance)) { cdm.EmitNew(request.Emitter, Rng, instance); var mangled = cdm.Codec.Mangle(value); Debug.Assert(Equals(cdm.Codec.Demangle(mangled), value)); cdm.EmitCall(request.Emitter, Rng, instance, mangled); } }
public void Feature() { // Arrange var request = new FeatureRequest(); request.Params.Add(new FeatureRequestParams { Feature = "4C97EBA926031A7CF7D7B36FDE3ED66DDA5421192D63DE53FFB46E43B9DC8373", Vetoed = false }); // Act var response = _client.Server.FeatureAsync(request).Result; // Assert Assert.AreEqual(Status.Success, response.Result.Status); }
public async Task <FeaturesResponse> GetFeaturedAsync(FeatureRequest request) { var uri = RouteBuilder("features", request); HttpResponseMessage response = await _client.GetAsync(uri); if (response.IsSuccessStatusCode) { var jsonResult = await response.Content.ReadAsStringAsync(); var results = JsonConvert.DeserializeObject <FeaturesResponse>(jsonResult); return(results); } return(new FeaturesResponse() { Status = response.StatusCode.ToString() }); }
public void Save(FeatureRequest featureRequest) { if (featureRequest.Id == 0) { context.FeatureRequests.Add(featureRequest); } else { var dbEntry = context.FeatureRequests.Find(featureRequest.Id); if (dbEntry != null) { dbEntry.Name = featureRequest.Name; dbEntry.Description = featureRequest.Description; dbEntry.ModifiedDate = DateTime.Now; dbEntry.Status = featureRequest.Status; dbEntry.RequestedBy = featureRequest.RequestedBy; } } context.SaveChanges(); }
public FeatureRequest FeatureRequestGet(int id) { FeatureRequest retVal = null; using (IDbConnection conn = DbHelper.GetDBConnection()) { try { var para = new DynamicParameters(); para.Add("@p_Id", id, dbType: DbType.Int32); retVal = conn.Query <FeatureRequest>("dbo.OXO_FeatureRequest_Get", para, commandType: CommandType.StoredProcedure).FirstOrDefault(); } catch (Exception ex) { Log.Error(ex); throw; } } return(retVal); }
public ActionResult features(CreateFeatureRequestViewModel model) { if (ModelState.IsValid) { var userId = User.Identity.GetUserId(); var user = db.Users.Find(userId); if (user == null) { return(new HttpStatusCodeResult(HttpStatusCode.BadRequest)); } var fr = new FeatureRequest(); fr.Created = DateTime.Now; fr.Detail = model.Detail; fr.Email = model.Email; fr.Title = model.Title; fr.UserId = userId; db.FeatureRequests.Add(fr); db.SaveChanges(); ViewBag.Message = "Feature request submitted successfully. Thank you for your feedback."; } return(View(model)); }
public override StringMangleStackTop?Emit(IStringMangleContext context) { var part = context.Pieces.Peek(); if (part.Bits * part.Value.Length > 32) { return(null); } var emitter = context.Emitter; var fr = new FeatureRequest(Context, emitter); using (var r = fr.Enter(context.SourceMethod)) if (r != null) { part = context.Pieces.Dequeue(); var be = context.Mangler.Rng.NextBoolean(); var i = SmUtils.String2Int(part.Value, part.Bits, be); Context.IntMangler().Emit(fr, i); return(SmUtils.Int2String(context, part.Value.Length, part.Bits, be)); } return(null); }
public async Task Get_ReturnsExpectedFeature() { var client = fixture.CreateClient(); var uiSettings = fixture.Services.GetRequiredService <FeatureFlagUISettings>(); var request = new FeatureRequest { Name = nameof(TestFeature), Enabled = true }; await SetValueViaApiAsync(request); var response = await client.GetAsync( $"{uiSettings.ApiGetPath}?feature={request.Name}"); response.EnsureSuccessStatusCode(); var feature = await response.Content.ReadAsJson <FeatureResponse>(); Assert.True(feature.Enabled); Assert.Equal(nameof(TestFeature), feature.Name); Assert.Equal("Test feature description.", feature.Description); }
private static async Task UpdateReleaseAsync(HttpClient client, GitHubIssue[] allRequests, GitHubIssue[] allSpecs, GitHubIssue[] allProposals, Release release) { var response = await client.GetAsync($"https://api.zenhub.io/p1/reports/release/{release.ReleaseId}/issues"); ZenHubIssue[] issues = JsonConvert.DeserializeObject <ZenHubIssue[]>(await response.Content.ReadAsStringAsync()); release.Requests = new List <FeatureRequest>(); foreach (var issue in issues) { var req = allRequests.FirstOrDefault(i => i.IssueNumber == issue.IssueNumber); if (req != null) { var featureRequest = new FeatureRequest() { Title = TrimStart(req.Title, "Request: "), IssueNumber = req.IssueNumber }; //var dependency = dependencies.Dependencies.FirstOrDefault(i => i.Blocked.IssueNumber == featureRequest.IssueNumber); //if (dependency != null) //{ //var specIssue = allSpecs.FirstOrDefault(i => i.IssueNumber == dependency.Blocking.IssueNumber); var specIssue = allSpecs.FirstOrDefault(i => DoesIssueReference(i, featureRequest.IssueNumber)); if (specIssue != null) { featureRequest.Spec = new Spec() { Title = TrimStart(TrimStart(specIssue.Title, "Spec: "), "Spec draft: "), IssueNumber = specIssue.IssueNumber }; if (specIssue.Labels.Any(i => i.Name == "Spec-Approved")) { featureRequest.Spec.SpecStatus = SpecStatus.Approved; } else if (specIssue.Labels.Any(i => i.Name == "Spec-Ready for Review")) { featureRequest.Spec.SpecStatus = SpecStatus.ReadyForReview; } else if (specIssue.Labels.Any(i => i.Name == "Spec-Has Concerns")) { featureRequest.Spec.SpecStatus = SpecStatus.HasConcerns; } else { featureRequest.Spec.SpecStatus = SpecStatus.Draft; } } //} // If there's no spec, then look for proposals if (featureRequest.Spec == null) { featureRequest.Proposals = allProposals.Where(i => DoesIssueReference(i, featureRequest.IssueNumber)).Select(i => new Proposal() { Title = TrimStart(i.Title, "Proposal: "), IssueNumber = i.IssueNumber, SpecStatus = GetSpecStatusFromProposal(i) }).ToArray(); } release.Requests.Add(featureRequest); } } }
public async Task <IActionResult> Create(RequestEditModel model) { var user = await _userManager.GetUserAsync(HttpContext.User); model.Results = new List <RequestResult>(); if (ModelState.IsValid) { var request = new SearchRequest { Address = model.Address, Area = model.Area, Cost = model.Cost }; if (user != null) { request.UserId = user.Id; _context.SearchRequests.Add(request); foreach (KeyValuePair <Guid, String> kvp in model.Features) { var feature = new FeatureRequest { SearchRequestId = request.Id, FeatureTypeId = kvp.Key, Value = kvp.Value }; _context.FeatureRequests.Add(feature); } } var residences = await _context.Residences .Where(r => r.Cost <1.25 * model.Cost && r.Area> 0.75 *model.Area) .Include(r => r.Features) .ThenInclude(f => f.FeatureType) .ToListAsync(); foreach (var residence in residences) { double criterias = 0, goodCriterias = 0; goodCriterias += Math.Min(model.Area / residence.Area, residence.Area / model.Area); criterias++; goodCriterias += Math.Min(model.Cost / residence.Cost, residence.Cost / model.Cost); criterias++; foreach (var criteria in model.Features) { var residenceValue = residence.Features.Where(f => f.FeatureTypeId == criteria.Key).First().Value; if (criteria.Value == "Not Specified" || criteria.Value == residenceValue) { goodCriterias++; } criterias++; } if (goodCriterias / criterias > 0.75) { var requestResult = new RequestResult { Relevance = goodCriterias / criterias, SearchRequestId = request.Id, ResidenceId = residence.Id }; if (user != null) { _context.RequestResults.Add(requestResult); } model.Results.Add(new RequestResult { Relevance = goodCriterias / criterias, ResidenceId = residence.Id, Residence = await _context.Residences .Where(r => r.Id == residence.Id) .Include(r => r.Type) .Include(r => r.Features) .Include(r => r.ResidencePhotos) .SingleOrDefaultAsync() }); } } await _context.SaveChangesAsync(); if (user != null) { return(Redirect("/Requests/Edit/" + request.Id.ToString())); } } return(View(model)); }
public async Task <FeaturesResponse> GetAsync(FeatureRequest request) { return(await _breweryDb.Feature.GetFeaturedAsync(request)); }
public async Task <RpcJsonResponse <FeatureResult> > FeatureAsync(FeatureRequest request) { return(await PostAsync <RpcJsonResponse <FeatureResult>, FeatureResult>(request)); }
public async Task <FeaturesResponse> Get([FromUri] FeatureRequest request) { return(await _FeatureOrchestrator.GetAsync(request)); }
private string RouteBuilder(string path, FeatureRequest request = null) { return($"{_baseAddress}{path}?key={_key}{request?.ToString()}"); }
public async Task <FeaturesResponse> GetAsync(FeatureRequest request) { return(await _featureRepository.GetAsync(request)); }