private void DumpPackageContents(LibraryDescription library, SelectionCriteria criteria)
{
var packageContents = new ContentItemCollection();
packageContents.Load(library.Path);
var group = packageContents.FindBestItemGroup(criteria, Patterns.ManagedAssemblies);
if (group == null)
{
// No matching groups
return;
}
Logger.WriteInformation(library.ToString().White());
Logger.WriteInformation("=========================");
foreach (var item in group.Items)
{
Logger.WriteInformation(item.Path.White());
foreach (var property in item.Properties)
{
Logger.WriteInformation(property.Key.Yellow() + " = " + property.Value);
}
}
Logger.WriteInformation("=========================");
Console.WriteLine();
}
/// <summary>
/// Sets the currently selected element
/// </summary>
/// <param name="modelElement"></param>
/// <param name="source"></param>
/// <param name="criteria"></param>
public void SelectElement(IModelElement modelElement, object source, SelectionCriteria criteria)
{
SelectionContext selectionContext = new SelectionContext(modelElement, source, criteria);
// Updates the selection history
if (SelectionHistory.Count > 0)
{
// Only consider selection changes
if (modelElement != SelectionHistory[0].Element)
{
// Avoid overflow of the selection history
if (SelectionHistory.Count > MaxSelectionHistory)
{
SelectionHistory.RemoveAt(SelectionHistory.Count - 1);
}
SelectionHistory.Insert(0, selectionContext);
}
}
else
{
SelectionHistory.Insert(0, selectionContext);
}
OnSelectionChange(selectionContext);
}
/// <summary>
/// Validates that the compatible frameworks have compatible surface area.
/// </summary>
/// <param name="package">Nuget Package that needs to be validated.</param>
public void Validate(Package package)
{
_apiCompatRunner.InitializePaths(package.PackagePath, package.PackagePath);
IEnumerable <ContentItem> compileAssets = package.CompileAssets.OrderByDescending(t => ((NuGetFramework)t.Properties["tfm"]).Version);
ManagedCodeConventions conventions = new ManagedCodeConventions(null);
Queue <ContentItem> compileAssetsQueue = new Queue <ContentItem>(compileAssets);
while (compileAssetsQueue.Count > 0)
{
ContentItem compileTimeAsset = compileAssetsQueue.Dequeue();
ContentItemCollection contentItemCollection = new();
contentItemCollection.Load(compileAssetsQueue.Select(t => t.Path));
NuGetFramework framework = (NuGetFramework)compileTimeAsset.Properties["tfm"];
SelectionCriteria managedCriteria = conventions.Criteria.ForFramework(framework);
ContentItem compatibleFrameworkAsset = null;
if (package.HasRefAssemblies)
{
compatibleFrameworkAsset = contentItemCollection.FindBestItemGroup(managedCriteria, conventions.Patterns.CompileRefAssemblies)?.Items.FirstOrDefault();
}
else
{
compatibleFrameworkAsset = contentItemCollection.FindBestItemGroup(managedCriteria, conventions.Patterns.CompileLibAssemblies)?.Items.FirstOrDefault();
}
if (compatibleFrameworkAsset != null && compatibleFrameworkAsset.Path != compileTimeAsset.Path)
{
string header = string.Format(Resources.ApiCompatibilityHeader, compatibleFrameworkAsset.Path, compileTimeAsset.Path);
_apiCompatRunner.QueueApiCompatFromContentItem(package.PackageId, compatibleFrameworkAsset, compileTimeAsset, header);
}
}
_apiCompatRunner.RunApiCompat();
}
//FIXED-NOV15 Create separate model "SelectionCriteria" for all properties
public JsonResult ReviewAllClaims(SelectionCriteria selectionCriteria)
{
if (selectionCriteria.StartDate == DateTime.MinValue ||
selectionCriteria.EndDate == DateTime.MinValue || selectionCriteria.StartDate == null ||
selectionCriteria.EndDate == null)
{
selectionCriteria.EndDate = DateTime.Now;
selectionCriteria.StartDate =
DateTime.Now.AddYears(-GlobalConfigVariable.PullDataForNumberOfYears);
}
SelectionCriteria criteria = new SelectionCriteria
{
ClaimSearchCriteria = selectionCriteria.ClaimSearchCriteria,
UserName = GetCurrentUserName(),
StartDate = Convert.ToDateTime(selectionCriteria.StartDate),
EndDate = Convert.ToDateTime(selectionCriteria.EndDate),
ModelId = Convert.ToInt64(selectionCriteria.ModelId),
DateType = Convert.ToInt32(selectionCriteria.DateType),
};
return
(Json(
new
{
success =
PostApiResponse <bool>(Constants.ClaimSelection, Constants.ReviewedAllClaims,
criteria)
}));
}
public RadioDevices()
{
var broadcastStationsRepository = new BroadcastStationsRepository();
Repository = broadcastStationsRepository;
Criteria = new SelectionCriteria();
}
private XElement SerializeSelectionCriteria(SelectionCriteria selectionCriteria)
{
var selectionCriteriaElement = new XElement("SelectionCriteria",
new XElement("CriteriaCondition", selectionCriteria.CriteriaCondition.ToString()),
new XElement("ApprovedProvidersOnly", selectionCriteria.ApprovedProvidersOnly.ToString()),
new XElement("ProviderStatus", selectionCriteria.ProviderStatus.ToString()),
new XElement("StakeholderId", selectionCriteria.StakeholderId));
if (selectionCriteria.UnitedKingdomProviderReferenceNumberList != null &&
selectionCriteria.UnitedKingdomProviderReferenceNumberList.Length > 0)
{
var ukprnElements = selectionCriteria.UnitedKingdomProviderReferenceNumberList
.Select(ukprn => new XElement("UnitedKingdomProviderReferenceNumber", ukprn))
.ToArray();
selectionCriteriaElement.Add(
new XElement("UnitedKingdomProviderReferenceNumberList", ukprnElements));
}
if (selectionCriteria.ProviderUpdatedSince.HasValue)
{
var providerUpdatedSinceValue = selectionCriteria.ProviderUpdatedSince.Value.ToUniversalTime().ToString("O");
selectionCriteriaElement.Add(new XElement("ProviderUpdatedSince", providerUpdatedSinceValue));
}
return(selectionCriteriaElement);
}
public void EmitSelectionCriteria()
{
var n1 = new PhysicalValue()
{
Number = 51
};
var n2 = new PhysicalValue()
{
Number = 52
};
var sc = new SelectionCriteria()
{
BinaryRelation = ">",
FirstArgument = n1,
SecondArgument = n2
};
var ms = new StringWriter();
sc.Emit(ms);
var text = ms.ToString().Split('\r').Select(l => l.Trim()).ToArray();
Assert.AreEqual("atlas:number0 rdf:type qudt:QuantityValue ;", text[0]);
Assert.AreEqual("qudt:numericValue \"51\"^^xsd:decimal .", text[1]);
Assert.AreEqual("", text[2]);
Assert.AreEqual("atlas:number1 rdf:type qudt:QuantityValue ;", text[3]);
Assert.AreEqual("qudt:numericValue \"52\"^^xsd:decimal .", text[4]);
Assert.AreEqual("", text[5]);
Assert.AreEqual("atlas:selectionCriteria2 rdf:type dfs:SelectionCriteria ;", text[6]);
Assert.AreEqual("dfs:usesBinaryRelation dfs:greaterThan ;", text[7]);
Assert.AreEqual("dfs:hasFirstArgument atlas:number0 ;", text[8]);
Assert.AreEqual("dfs:hasSecondArgument atlas:number1 .", text[9]);
}
private SelectionCriteria Convert(FinalStatePatternParser.CutBinaryContext context)
{
var c = new SelectionCriteria();
c.BinaryRelation = context.BINARY_OP().GetText();
c.FirstArgument = Convert(context.cut_arg()[0]);
c.SecondArgument = Convert(context.cut_arg()[1]);
return(c);
}
public ActionResult Create(SelectionCriteria selectionCriteria)
{
try
{
SelectionCriteria sc = db.SelectionCriterias.FirstOrDefault(s => s.BatchProgramID == selectionCriteria.BatchProgramID &&
s.DegreeID == selectionCriteria.DegreeID);
if (sc == null)
{
selectionCriteria.CreatedBy = Convert.ToInt32(Session["emp_id"]);
selectionCriteria.CreatedOn = DateTime.Now;
db.SelectionCriterias.Add(selectionCriteria);
try
{
db.SaveChanges();
ViewBag.MessageType = "success";
ViewBag.Message = "Data has been saved successfully.";
}
catch (DbUpdateException ex)
{
ViewBag.MessageType = "error";
ViewBag.Message = ex.Message;
ModelState.AddModelError(string.Empty, ex.Message);
}
}
else
{
ModelState.AddModelError(string.Empty, "Selected Batch Program is already exists against selected Degree.");
ViewBag.MessageType = "error";
ViewBag.Message = "Selected Batch Program is already exists against selected Degree.";
}
}
catch (DbEntityValidationException ex)
{
string ErrorMessage = "";
int count = 0;
foreach (DbEntityValidationResult validationResult in ex.EntityValidationErrors)
{
string entityName = validationResult.Entry.Entity.GetType().Name;
foreach (DbValidationError error in validationResult.ValidationErrors)
{
ModelState.AddModelError(string.Empty, error.ErrorMessage);
count++;
ErrorMessage += count + "-" + string.Concat(error.PropertyName, " is required.") + "<br />";
}
}
ViewBag.MessageType = "error";
ViewBag.Message = ErrorMessage;
}
model.SelectionCriterias = db.SelectionCriterias.OrderByDescending(s => s.CriteriaID).ToList();
model.SelectedSelectionCriteria = null;
model.DisplayMode = "WriteOnly";
ViewBag.IsActive = new SelectList(db.Options, "OptionDesc", "OptionDesc", selectionCriteria.IsActive);
ViewBag.BatchProgramID = new SelectList(db.GetBatchProgramNameConcat("", 0), "ID", "Name", selectionCriteria.BatchProgramID);
ViewBag.DegreeID = new SelectList(db.Degrees, "DegreeID", "DegreeName", selectionCriteria.DegreeID);
return(View("Index", model));
}
public IDbCommand BuildForSelectionCriteria(SelectionCriteria aSelectionCriteria)
{
string partOfCriteria = " WHERE 1=1 ";
partOfCriteria += " AND " + aSelectionCriteria.BuildSqlOperator();
IDbCommand cmd = m_ClassMap.PersistenceProvider.GetCommand();
cmd.CommandText = this.m_SelectFromClause + partOfCriteria;
return(cmd);
}
private void ProcessSelectionArea()
{
// If selecting with mouse pointer only (no box selection)
if (!_isBoxSelecting)
{
var selectedObjects = SelectionManager.GetSelectedObjects();
try
{
if (selectedObjects.Count == 1)
{
var selectedObject = selectedObjects[0];
var entity = EntityManager.GetEntityInParent(selectedObject);
if (entity != null)
{
_uiManager.OnSelectEntity(entity);
}
}
else if (selectedObjects.Count == 0)
{
SelectionManager.UpdateMouseSelection(_mouseOverObject, null);
}
}
catch (MissingReferenceException e)
{
// if object gets destroyed, it may still be referenced here if selection manager doesnt update 'currently selected'
Debug.Log("Warning: trying to inspect a destroyed object.");
SelectionManager.CheckMissingSelected(); // TODO: optionally remove this
}
return;
}
if (_startedBoxSelection)
{
_startedBoxSelection = false;
OnDeselectObjects();
}
// placeholder selection
var selectionCriteria = new SelectionCriteria(
isAgent: true,
isBuilding: false,
isControllable: true,
SelectionCriteria.ECondition.Or,
gameSession.CurrentPlayer.ownership.info
);
// TODO ADD CRITERIA/SORTING of selected objects
SelectionManager.UpdateSelected(
_mousePositionAtSelectionStart, _mousePositionAtSelectionEnd,
_mouseOverObject, selectionCriteria);
}
public static TModel FromSelectionCriteria <TModel>(SelectionCriteria selectionCriteria) where
TModel : SelectionCriteriaApiModel, new()
{
var model = new TModel();
model.Id = selectionCriteria.Id;
model.TenantId = selectionCriteria.TenantId;
model.Name = selectionCriteria.Name;
model.Description = selectionCriteria.Description;
return(model);
}
public static void FixCriteria(SelectionCriteria criteria)
{
// workaround https://github.com/NuGet/Home/issues/1457
foreach (var criterium in criteria.Entries)
{
if (criterium.Properties.ContainsKey(ManagedCodeConventions.PropertyNames.TargetFrameworkMoniker) &&
!criterium.Properties.ContainsKey(ManagedCodeConventions.PropertyNames.RuntimeIdentifier))
{
criterium.Properties.Add(ManagedCodeConventions.PropertyNames.RuntimeIdentifier, null);
}
}
}
public static bool IsLookupItemEligible <T>(this SelectionCriteria <T> set, int index)
where T : class
{
var element = set.LookupList[index];
foreach (var item in set.EligibleList)
{
if (item.Equals(element))
{
return(true);
}
}
return(false);
}
public string GetBestSupportedTargetFramework(IEnumerable <string> supportedTargetFrameworks, string targetFramework)
{
var contentCollection = new ContentItemCollection();
contentCollection.Load(supportedTargetFrameworks.Select(t => t + '/').ToArray());
string[] splitStrings = targetFramework.Split('-');
string targetFrameworkWithoutSuffix = splitStrings[0];
string targetFrameworkSuffix = splitStrings.Length > 1 ? splitStrings[1] : string.Empty;
SelectionCriteria criteria = _conventions.Criteria.ForFrameworkAndRuntime(NuGetFramework.Parse(targetFrameworkWithoutSuffix), targetFrameworkSuffix);
string bestTargetFrameworkString = contentCollection.FindBestItemGroup(criteria, _configStringPattern)?.Items[0].Path;
return(bestTargetFrameworkString?.Remove(bestTargetFrameworkString.Length - 1));
}
private SelectionCriteria GetSelectionCriteria(NuGetFramework projectFramework)
{
// This API isn't great but it allows you the client to build up search criteria
// based on patterns inside of the package
var criteria = new SelectionCriteria();
var entry = new SelectionCriteriaEntry();
entry.Properties["tfm"] = projectFramework;
entry.Properties["tpm"] = null;
criteria.Entries.Add(entry);
return(criteria);
}
public async Task <AddOrUpdateSelectionCriteriaResponse> Handle(AddOrUpdateSelectionCriteriaRequest request)
{
var entity = await _context.SelectionCriterion
.SingleOrDefaultAsync(x => x.Id == request.SelectionCriteria.Id && x.TenantId == request.TenantId);
if (entity == null)
{
_context.SelectionCriterion.Add(entity = new SelectionCriteria());
}
entity.Name = request.SelectionCriteria.Name;
entity.Description = request.SelectionCriteria.Description;
entity.TenantId = request.TenantId;
await _context.SaveChangesAsync();
return(new AddOrUpdateSelectionCriteriaResponse());
}
/// <summary>
/// Dump out a selection criteria.
/// </summary>
/// <param name="sc"></param>
/// <param name="wr"></param>
/// <returns></returns>
public static string Emit(this SelectionCriteria sc, TextWriter wr)
{
var n1 = sc.FirstArgument.Emit(wr);
wr.WriteLine();
var n2 = sc.SecondArgument.Emit(wr);
wr.WriteLine();
var name = MakeName("selectionCriteria");
wr.WriteLine($"{OWLNamespace}:{name} rdf:type dfs:SelectionCriteria ;", name);
wr.WriteLine($" dfs:usesBinaryRelation dfs:{AsDFSBinaryRelation(sc.BinaryRelation)} ;");
wr.WriteLine($" dfs:hasFirstArgument {OWLNamespace}:{n1} ;");
wr.WriteLine($" dfs:hasSecondArgument {OWLNamespace}:{n2} .");
return(name);
}
public ActionResult Edit(SelectionCriteria selectionCriteria)
{
try
{
db.Entry(selectionCriteria).State = EntityState.Modified;
selectionCriteria.ModifiedBy = Convert.ToInt32(Session["emp_id"]);
selectionCriteria.ModifiedOn = DateTime.Now;
try
{
db.SaveChanges();
ViewBag.MessageType = "success";
ViewBag.Message = "Data has been saved successfully.";
}
catch (DbUpdateException ex)
{
ViewBag.MessageType = "error";
ViewBag.Message = ex.Message;
ModelState.AddModelError(string.Empty, ex.Message);
}
}
catch (DbEntityValidationException ex)
{
string ErrorMessage = "";
int count = 0;
foreach (DbEntityValidationResult validationResult in ex.EntityValidationErrors)
{
string entityName = validationResult.Entry.Entity.GetType().Name;
foreach (DbValidationError error in validationResult.ValidationErrors)
{
ModelState.AddModelError(string.Empty, error.ErrorMessage);
count++;
ErrorMessage += string.Concat(count, "-", error.ErrorMessage, "\n");
}
}
ViewBag.MessageType = "error";
ViewBag.Message = ErrorMessage;
}
model.SelectionCriterias = db.SelectionCriterias.OrderByDescending(s => s.CriteriaID).ToList();
model.SelectedSelectionCriteria = null;
model.DisplayMode = "WriteOnly";
ViewBag.IsActive = new SelectList(db.Options, "OptionDesc", "OptionDesc", selectionCriteria.IsActive);
ViewBag.BatchProgramID = new SelectList(db.GetBatchProgramNameConcat("", 0), "ID", "Name", selectionCriteria.BatchProgramID);
ViewBag.DegreeID = new SelectList(db.Degrees, "DegreeID", "DegreeName", selectionCriteria.DegreeID);
return(View("Index", model));
}
/// <summary>
/// The user has given us a range cut
/// </summary>
/// <param name="context"></param>
public override void ExitCutRange(FinalStatePatternParser.CutRangeContext context)
{
var c1 = new SelectionCriteria();
var c2 = new SelectionCriteria();
c1.BinaryRelation = context.BINARY_OP(0).GetText();
c2.BinaryRelation = context.BINARY_OP(1).GetText();
c1.FirstArgument = Convert(context.cut_number(0));
c1.SecondArgument = Convert(context.cut_name());
c2.FirstArgument = Convert(context.cut_name());
c2.SecondArgument = Convert(context.cut_number(1));
_current_criteria.Peek().Add(c1);
_current_criteria.Peek().Add(c2);
base.ExitCutRange(context);
}
// FIXED-NOV15 Move this method into SelectClaimRepository
/// <summary>
/// Reviewed all claims.
/// </summary>
/// <param name="selectionCriteria">The selection criteria.</param>
/// <returns></returns>
public bool ReviewedAllClaims(SelectionCriteria selectionCriteria)
{
if (selectionCriteria != null)
{
// Initialize the Stored Procedure
_databaseCommand = _databaseObj.GetStoredProcCommand("ClaimsAllReviewed");
// Pass parameters to Stored Procedure(i.e., @ParamName), add values for
_databaseObj.AddInParameter(_databaseCommand, "@SelectCriteria ", DbType.String, selectionCriteria.ClaimSearchCriteria);
_databaseObj.AddInParameter(_databaseCommand, "@ModelId", DbType.Int64, selectionCriteria.ModelId);
_databaseObj.AddInParameter(_databaseCommand, "@DateType ", DbType.Int32, selectionCriteria.DateType);
_databaseObj.AddInParameter(_databaseCommand, "@StartDate ", DbType.DateTime, selectionCriteria.StartDate);
_databaseObj.AddInParameter(_databaseCommand, "@EndDate ", DbType.DateTime, selectionCriteria.EndDate);
_databaseObj.AddInParameter(_databaseCommand, "@UserName", DbType.String, selectionCriteria.UserName);
// Retrieve the results of the Stored Procedure
return(_databaseObj.ExecuteNonQuery(_databaseCommand) > 0);
}
return(false);
}
/// <summary>
/// Validates that the compatible frameworks have compatible surface area.
/// </summary>
/// <param name="package">Nuget Package that needs to be validated.</param>
public void Validate(PackageValidatorOption option)
{
ApiCompatRunner apiCompatRunner = new(_log,
option.EnableStrictMode,
option.FrameworkReferences,
option.Package.PackagePath);
ManagedCodeConventions conventions = new(null);
PatternSet patternSet = option.Package.RefAssets.Any() ?
conventions.Patterns.CompileRefAssemblies :
conventions.Patterns.CompileLibAssemblies;
IEnumerable <ContentItem> compileAssets = option.Package.CompileAssets.OrderByDescending(t => ((NuGetFramework)t.Properties["tfm"]).Version);
Queue <ContentItem> compileAssetsQueue = new(compileAssets);
while (compileAssetsQueue.Count > 0)
{
ContentItem compileTimeAsset = compileAssetsQueue.Dequeue();
// If no assets are available for comparison, stop the iteration.
if (compileAssetsQueue.Count == 0)
{
break;
}
// The runtime graph doesn't need to be passed in to the collection as compile time assets can't be rid specific.
ContentItemCollection contentItemCollection = new();
// The collection won't contain the current compile time asset as it is already dequeued.
contentItemCollection.Load(compileAssetsQueue.Select(t => t.Path));
NuGetFramework framework = (NuGetFramework)compileTimeAsset.Properties["tfm"];
SelectionCriteria managedCriteria = conventions.Criteria.ForFramework(framework);
// Searches for a compatible compile time asset and compares it.
ContentItem?compatibleFrameworkAsset = contentItemCollection.FindBestItemGroup(managedCriteria, patternSet)?.Items.FirstOrDefault();
if (compatibleFrameworkAsset != null)
{
string header = string.Format(Resources.ApiCompatibilityHeader, compatibleFrameworkAsset.Path, compileTimeAsset.Path);
apiCompatRunner.QueueApiCompatFromContentItem(option.Package.PackageId, compatibleFrameworkAsset, compileTimeAsset, header);
}
}
apiCompatRunner.RunApiCompat();
}
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
SelectionCriteria selectionCriteria = db.SelectionCriterias.Find(id);
if (selectionCriteria == null)
{
return(HttpNotFound());
}
model.SelectionCriterias = db.SelectionCriterias.OrderByDescending(s => s.CriteriaID).ToList();
model.SelectedSelectionCriteria = selectionCriteria;
model.DisplayMode = "Delete";
ViewBag.MessageType = "";
ViewBag.Message = "";
return(View("Index", model));
}
void ProcessSelectionArea()
{
// TODO LIST CRITERIA
SelectionCriteria selectionCriteria = new SelectionCriteria(true, false, true, gameSession.currentPlayer.ownership.info);
if (!isBoxSelecting)
{
if (selectionManager.GetSelectedObjects().Count == 0)
{
selectionManager.UpdateMouseSelection(mouseOverObject, null);
}
return;
}
if (startedBoxSelection)
{
selectionManager.DeselectAll();
startedBoxSelection = false;
}
selectionManager.UpdateSelected(mousePositionAtSelectionStart, mousePositionAtSelectionEnd, mouseOverObject, selectionCriteria);
}
public ActionResult DeleteConfirmed(int id)
{
try
{
SelectionCriteria selectionCriteria = db.SelectionCriterias.Find(id);
db.SelectionCriterias.Remove(selectionCriteria);
db.SaveChanges();
ViewBag.MessageType = "success";
ViewBag.Message = "Record has been removed successfully.";
}
catch (DbUpdateException ex)
{
ViewBag.MessageType = "error";
ViewBag.Message = ex.Message;
ModelState.AddModelError(string.Empty, ex.Message);
}
model.SelectionCriterias = db.SelectionCriterias.OrderByDescending(s => s.CriteriaID).ToList();
model.SelectedSelectionCriteria = null;
model.DisplayMode = "WriteOnly";
ViewBag.IsActive = new SelectList(db.Options, "OptionDesc", "OptionDesc");
ViewBag.BatchProgramID = new SelectList(db.GetBatchProgramNameConcat("", 0), "ID", "Name");
ViewBag.DegreeID = new SelectList(db.Degrees, "DegreeID", "DegreeName");
return(View("Index", model));
}
private SelectionCriteria GetSelectionCriteria()
{
var criteria = new SelectionCriteria();
criteria.Entries.Add(new SelectionCriteriaEntry
{
Properties = new Dictionary <string, object>
{
{ "tpm", NuGetFramework.Parse(TargetPlatformMonikers.First()) },
{ "tfm", NuGetFramework.Parse(TargetFrameworkMonikers.First()) },
{ "arch", Architecture }
}
});
criteria.Entries.Add(new SelectionCriteriaEntry
{
Properties = new Dictionary <string, object>
{
{ "tfm", NuGetFramework.Parse(TargetFrameworkMonikers.First()) }
}
});
return(criteria);
}
public ActionResult Update(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
SelectionCriteria selectionCriteria = db.SelectionCriterias.Find(id);
if (selectionCriteria == null)
{
return(HttpNotFound());
}
model.SelectionCriterias = db.SelectionCriterias.OrderByDescending(s => s.CriteriaID).ToList();
model.SelectedSelectionCriteria = selectionCriteria;
model.DisplayMode = "ReadWrite";
ViewBag.IsActive = new SelectList(db.Options, "OptionDesc", "OptionDesc", selectionCriteria.IsActive);
ViewBag.BatchProgramID = new SelectList(db.GetBatchProgramNameConcat("", 0), "ID", "Name", selectionCriteria.BatchProgramID);
ViewBag.DegreeID = new SelectList(db.Degrees, "DegreeID", "DegreeName", selectionCriteria.DegreeID);
ViewBag.MessageType = "";
ViewBag.Message = "";
return(View("Index", model));
}
public string GetBestSupportedTargetFramework(IEnumerable <string> supportedTargetFrameworks, string targetFramework)
{
List <string> exactConfigs = supportedTargetFrameworks.Where(t => !t.StartsWith("_")).ToList();
IEnumerable <string> placeHolderConfigs = supportedTargetFrameworks.Where(t => t.StartsWith("_")).Select(t => t.Substring(1));
if (placeHolderConfigs.Any())
{
exactConfigs.AddRange(placeHolderConfigs);
}
var contentCollection = new ContentItemCollection();
contentCollection.Load(exactConfigs.Select(t => t + '/').ToArray());
string[] splitStrings = targetFramework.Split('-');
string targetFrameworkWithoutSuffix = splitStrings[0];
string targetFrameworkSuffix = splitStrings.Length > 1 ? splitStrings[1] : string.Empty;
SelectionCriteria criteria = _conventions.Criteria.ForFrameworkAndRuntime(NuGetFramework.Parse(targetFrameworkWithoutSuffix), targetFrameworkSuffix);
string bestTargetFrameworkString = contentCollection.FindBestItemGroup(criteria, _configStringPattern)?.Items[0].Path;
string bestTargetFrameworkStringWithoutSlash = bestTargetFrameworkString?.Remove(bestTargetFrameworkString.Length - 1);
return(placeHolderConfigs.Any() && placeHolderConfigs.Contains(bestTargetFrameworkStringWithoutSlash) ? null : bestTargetFrameworkStringWithoutSlash);
}
/// <summary>
/// Instantiates a case with the match and criteria provided.
/// </summary>
/// <param name="match">The match that determines if this case applies to a configuration.</param>
/// <param name="criteria">The selection criteria for use by behaviours.</param>
public Case(Predicate<IConfiguration> match, SelectionCriteria criteria)
{
_match = match;
_criteria = criteria;
}
/// <summary>
/// Flushes the select operations.
/// </summary>
/// <param name="criteria">The criteria.</param>
public void FlushSelectOperations(SelectionCriteria criteria)
{
FlushEvents(criteria, this._eventQueue);
}
public NugetRepositoryEntry ResolveGroups(LocalPackageSourceInfo localPackageSourceInfo)
{
var collection = new ContentItemCollection();
collection.Load(localPackageSourceInfo.Package.Files);
var allPackageDependencyGroups = localPackageSourceInfo.Package.Nuspec.GetDependencyGroups().ToArray();
var frameworkReferenceGroups = localPackageSourceInfo.Package.Nuspec.GetFrameworkRefGroups().ToArray();
var entry = new NugetRepositoryEntry(localPackageSourceInfo);
foreach (var target in _targets)
{
SelectionCriteria criteria = _conventions.Criteria.ForFrameworkAndRuntime(target.Framework, target.RuntimeIdentifier);
// The nunit3testadapter package publishes dll's in build/
var buildAssemblies = new PatternSet(_conventions.Properties, new[]
{
new PatternDefinition("build/{tfm}/{any?}"),
new PatternDefinition("build/{assembly?}")
}, new[]
{
new PatternDefinition("build/{tfm}/{assembly}"),
new PatternDefinition("build/{assembly}")
});
// shipped debug binaries
var netcoreappdebugAssemblies = new PatternSet(_conventions.Properties, new[]
{
new PatternDefinition("netcoreappdebug/{tfm}/{any?}"),
new PatternDefinition("netcoreappdebug/{assembly?}")
}, new[]
{
new PatternDefinition("netcoreappdebug/{tfm}/{assembly}"),
new PatternDefinition("netcoreappdebug/{assembly}")
});
// The analyzer dll's are published in analyzers/ or analyzers/dotnet/cs/
var analyzerAssemblies = new PatternSet(_conventions.Properties, new []
{
new PatternDefinition("analyzers/dotnet/cs/{assembly?}"),
new PatternDefinition("analyzers/{assembly?}")
}, new []
{
new PatternDefinition("analyzers/dotnet/cs/{assembly}"),
new PatternDefinition("analyzers/{assembly}")
});
AddIfNotNull(entry.RefItemGroups, target.Framework,
collection.FindBestItemGroup(criteria,
_conventions.Patterns.CompileRefAssemblies,
_conventions.Patterns.CompileLibAssemblies)
?.Items);
AddIfNotNull(entry.RuntimeItemGroups, target.Framework,
collection.FindBestItemGroup(criteria,
_conventions.Patterns.RuntimeAssemblies,
_conventions.Patterns.NativeLibraries,
buildAssemblies)
?.Items.Where(IsDll));
AddIfNotNull(entry.DebugRuntimeItemGroups, target.Framework,
collection.FindItemGroups(netcoreappdebugAssemblies)
.SingleOrDefault()
?.Items.Where(IsDll));
AddIfNotNull(entry.ContentFileGroups, target.Framework,
collection.FindBestItemGroup(criteria,
_conventions.Patterns.ContentFiles)
?.Items);
AddIfNotNull(entry.AnalyzerItemGroups, target.Framework,
collection.FindItemGroups(analyzerAssemblies)
.SingleOrDefault()
?.Items);
// Merge FrameworkReferences with normal PackageReferences
var dependencies = NuGetFrameworkUtility.GetNearest(allPackageDependencyGroups, target.Framework);
var frameworks = NuGetFrameworkUtility.GetNearest(frameworkReferenceGroups, target.Framework);
if (dependencies != null || frameworks != null)
{
entry.DependencyGroups.Add(new PackageDependencyGroup(
dependencies?.TargetFramework ?? frameworks?.TargetFramework,
new[]
{
frameworks?.FrameworkReferences.Select(FrameworkDependencyResolver.ConvertToDependency),
dependencies?.Packages,
}
.SelectMany(v => v ?? Array.Empty <PackageDependency>())));
}
}
return(entry);
/// <summary>
/// Reviewed all claims.
/// </summary>
/// <param name="selectionCriteria">The selection criteria.</param>
/// <returns></returns>
public bool ReviewedAllClaims(SelectionCriteria selectionCriteria)
{
return(_claimSelectorRepository.ReviewedAllClaims(selectionCriteria));
}
/// <summary>
/// Flushes the events.
/// </summary>
/// <param name="criteria">The criteria.</param>
/// <param name="queue">The queue.</param>
private static void FlushEvents(SelectionCriteria criteria, Queue<IThreadPoolOperation> queue)
{
lock (queue)
{
if (queue.Count <= 0)
return;
var operations = new Queue<IThreadPoolOperation>();
while (queue.Count > 0)
{
var item = queue.Dequeue();
if (!criteria(item))
operations.Enqueue(item);
}
while (operations.Count > 0)
queue.Enqueue(operations.Dequeue());
}
}
