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));
}
