/// <summary>
/// Initialises a new instance of the <see cref="TableInfo"/> class.
/// </summary>
/// <param name="columns">The columns that are mapped for the table.</param>
/// <param name="identifierStrategy">The identifier strategy used by the table.</param>
/// <param name="name">The name of the table.</param>
/// <param name="schema">The database schema the table exists within (e.g. 'dbo'); otherwise null.</param>
/// <exception cref="ArgumentNullException">Thrown if columns or name are null.</exception>
/// <exception cref="MappingException">Thrown if no there is a problem with the column mappings.</exception>
public TableInfo(
IList<ColumnInfo> columns,
IdentifierStrategy identifierStrategy,
string name,
string schema)
{
if (columns == null)
{
throw new ArgumentNullException("columns");
}
if (name == null)
{
throw new ArgumentNullException("name");
}
this.columns = new ReadOnlyCollection<ColumnInfo>(columns);
this.identifierStrategy = identifierStrategy;
this.name = name;
this.schema = schema;
this.identifierColumn = columns.FirstOrDefault(c => c.IsIdentifier);
this.insertColumnCount = columns.Count(c => c.AllowInsert);
this.updateColumnCount = columns.Count(c => c.AllowUpdate);
this.ValidateColumns();
}
public override int Handle(IFrame frame, IList<IFrame> frames)
{
if (!CanHandle(frame)) return 0;
int frameScore = Configuration.NumberOfPins;
List<int> extraRolls = new List<int>();
var nextFrame = frames.FirstOrDefault(f => f.Sequence == frame.Sequence + 1);
while(nextFrame != null && extraRolls.Count < Configuration.NumberOfRollsPerFrame)
{
if (IsStrike(nextFrame))
{
extraRolls.Add(Configuration.NumberOfPins);
nextFrame = frames.FirstOrDefault(f => f.Sequence == frame.Sequence + 1);
}
else
{
extraRolls.Add(
nextFrame.Rolls
.Where(r => r.Pins.HasValue)
.Select(r => r.Pins.Value).ToArray()[extraRolls.Count]
);
}
}
return frameScore + extraRolls.Sum();
}
static IList<Edge> ExtractEdges(IList<CodeReference> references, IList<Node> nodes)
{
var edges = new List<Edge>();
var id = 0;
foreach (var reference in references)
{
id += 1;
var source = nodes.FirstOrDefault(node => node.label == reference.From);
var target = nodes.FirstOrDefault(node => node.label == reference.To);
if (source == null || target == null)
{
continue;
}
edges.Add(new Edge {
id = $"e{id}",
source = source.id,
target = target.id
});
}
return edges;
}
private static void Hydrate(IEnumerable <Session> sessions, IList <Speaker> speakers, IList <StreamUrl> streamUrls)
{
foreach (var session in sessions)
{
session.Speakers = new List <Speaker>();
session.StreamUrl = streamUrls?.FirstOrDefault(c => c.Name.Equals(session.Room))?.Url;
if (session.Title is "Welcome Keynote" or "Closing / Gifts")
{
session.StreamUrl = streamUrls?.FirstOrDefault(c => c.Name.Equals("Slot 1"))?.Url;
}
if (session.SpeakerIds == null)
{
continue;
}
foreach (var speakerId in session.SpeakerIds)
{
var speaker = speakers.FirstOrDefault(c => c.Id.Equals(speakerId));
if (speaker == null)
{
continue;
}
session.Speakers.Add(speaker);
}
}
}
public AccountTransactionDocument CreateDocument(Account account, string description, decimal amount, decimal exchangeRate, IList<AccountData> accounts, IList<ForeignCurrency> currencies)
{
var result = new AccountTransactionDocument { Name = Name, DocumentTypeId = Id };
foreach (var accountTransactionType in TransactionTypes)
{
var transaction = AccountTransaction.Create(accountTransactionType);
var amountRate = GetExchangeRate(accountTransactionType.ForeignCurrencyId, currencies);
amount = amount * amountRate;
transaction.UpdateAmount(amount, exchangeRate, accounts);
transaction.UpdateAccount(MasterAccountTypeId, account.Id);
if (accounts != null && accounts.Count > 0)
{
if (transaction.SourceAccountTypeId != MasterAccountTypeId &&
transaction.SourceTransactionValue.AccountId == 0)
{
var ac = accounts.FirstOrDefault(x => x.AccountTypeId == transaction.SourceAccountTypeId);
if (ac != null) transaction.SetSourceAccount(ac.AccountTypeId, ac.AccountId);
}
if (transaction.TargetAccountTypeId != MasterAccountTypeId &&
transaction.TargetTransactionValue.AccountId == 0)
{
var ac = accounts.FirstOrDefault(x => x.AccountTypeId == transaction.TargetAccountTypeId);
if (ac != null) transaction.SetTargetAccount(ac.AccountTypeId, ac.AccountId);
}
}
if (!string.IsNullOrEmpty(description))
{
transaction.UpdateDescription(description);
}
result.AccountTransactions.Add(transaction);
}
return result;
}
public object GetArg(IList<string> args)
{
if(args.Count == 0)
throw new Exception("too few arguments");
var first = args.FirstOrDefault();
var projectFilename = ZMFile.DefaultFilename;
if (first.EndsWith(".zm"))
{
projectFilename = first;
args.RemoveAt(0);
}
var targets = args.Where(x => !x.StartsWith("{")).ToList();
var parameterString = args.FirstOrDefault(x => x.StartsWith("{")) ?? string.Empty;
var parameters = new JObject();
if(!string.IsNullOrWhiteSpace(parameterString))
parameters = JObject.Parse(parameterString);
var result = new RunArg(projectFilename, targets, parameters);
return result;
}
private static string GetFunctionKeyFromCollection(IList <Key> keys)
{
Key key = keys?.FirstOrDefault();
return(keys?.FirstOrDefault(s => string.Equals(s.Name, ScriptConstants.DefaultFunctionKeyName))?.Value
?? key?.Value);
}
private RSTrackInfo findTrackContaining(IList<RSTrackInfo> songTracks, string[] preferences)
{
for(int i=0;i<preferences.Length;i++)
{
RSTrackInfo found = songTracks.FirstOrDefault(t => t.Name.Contains(preferences[i]));
if (found != null) return found;
}
return songTracks.FirstOrDefault();
}
/// <summary>
/// Combines and matches existing records with the updated records.
/// </summary>
/// <param name="updatedRecords">The calculated records with new wins, losses, and ties.</param>
/// <param name="existingRecords">The existing records that will need to be updated.</param>
/// <returns>List{UserRecord}. The collection of user records that should be updated or created.</returns>
public static List<UserRecord> CombineExistingRecordsWithUpdatedRecords(IList<UserRecord> updatedRecords, IList<UserRecord> existingRecords)
{
var records = new List<UserRecord>();
// Iterate through the updated records and checks if the user has a matching record that matches the record type
foreach (var record in updatedRecords)
{
UserRecord recordToUpdate = null;
if (record.RecordType == RecordType.Lifetime)
{
recordToUpdate = existingRecords.FirstOrDefault(existingRecord => MatchingLifetimeCondition(existingRecord, record));
}
else if (record.RecordType == RecordType.Season)
{
recordToUpdate = existingRecords.FirstOrDefault(existingRecord => MatchingSeasonCondition(existingRecord, record));
}
else if (record.RecordType == RecordType.SeasonType)
{
recordToUpdate = existingRecords.FirstOrDefault(existingRecord => MatchingSeasonTypeCondition(existingRecord, record));
}
else if (record.RecordType == RecordType.Week)
{
recordToUpdate = existingRecords.FirstOrDefault(existingRecord => MatchingWeekCondition(existingRecord, record));
}
// Create a new record since the user does not have an existing record for the record type
if (recordToUpdate == null)
{
recordToUpdate = new UserRecord
{
Losses = record.Losses,
RecordType = record.RecordType,
Season = record.Season,
SeasonType = record.SeasonType,
Ties = record.Ties,
UserId = record.UserId,
Week = record.Week,
Wins = record.Wins
};
}
// Update the existing record type's wins, losses, and ties.
else
{
recordToUpdate.Losses = record.Losses;
recordToUpdate.Ties = record.Ties;
recordToUpdate.Wins = record.Wins;
}
records.Add(recordToUpdate);
}
return records;
}
/// <summary>
/// Subscribes an one-way long running event.
/// This subscription will at best be valid until the destructor of this class is called
/// </summary>
/// <param name="messageType">Type of the message.</param>
/// <param name="asyncDeliveryAction">The asynchronous delivery action.</param>
/// <param name="asyncDeliveryActionName">Name of the asynchronous delivery action.</param>
/// <param name="unsubscribeOnMessageArrival">if set to <c>true</c> [unsubscribe on message arrival].</param>
/// <param name="context">The context.</param>
protected void SubscribeLongRunningEvent(Type messageType, Func <INotificationOneWayMessage, Task> asyncDeliveryAction, string asyncDeliveryActionName, bool unsubscribeOnMessageArrival = false, string context = AsyncSubscription.DefaultContext)
{
var equalLongSubscription = _longRunningMessageTokens?.FirstOrDefault(l => l.Token.MessageType == messageType);
if (equalLongSubscription != null)
{
NotificationManager.Unsubscribe(equalLongSubscription.Token);
_longRunningMessageTokens.Remove(equalLongSubscription);
}
var token = NotificationManager.Subscribe(messageType, OnLongRunningNotificationAsync, context);
_longRunningMessageTokens.Add(new LongRunningSubscriptionToken(token, asyncDeliveryAction, asyncDeliveryActionName, unsubscribeOnMessageArrival));
}
public static async Task <TrainingModels::Export> ExportIteration(
this ICustomVisionTrainingClient trainingApi, Guid projectId, Guid iterationId, string flavor = "onnx12", int timeoutInSecond = 30)
{
TimeSpan timeout = TimeSpan.FromSeconds(timeoutInSecond);
TrainingModels::Export exportIteration = null;
try
{
exportIteration = exportIteration = string.IsNullOrEmpty(flavor)
? await trainingApi.ExportIterationAsync(projectId, iterationId, platform)
: await trainingApi.ExportIterationAsync(projectId, iterationId, platform, flavor);
}
catch (HttpOperationException ex)
{
string exceptionContent = ex?.Response?.Content ?? string.Empty;
if (!exceptionContent.Contains("BadRequestExportAlreadyInProgress"))
{
throw ex;
}
}
DateTime startTime = DateTime.Now;
while (true)
{
IList <TrainingModels::Export> exports = await trainingApi.GetExportsAsync(projectId, iterationId);
exportIteration = string.IsNullOrEmpty(flavor)
? exports?.FirstOrDefault(x => string.Equals(x.Platform, platform, StringComparison.OrdinalIgnoreCase))
: exports?.FirstOrDefault(x => string.Equals(x.Platform, platform, StringComparison.OrdinalIgnoreCase) &&
string.Equals(x.Flavor, flavor, StringComparison.OrdinalIgnoreCase));
if (exportIteration?.Status == "Exporting")
{
await Task.Delay(1000);
}
else
{
break;
}
if (DateTime.Now - startTime > timeout)
{
throw new TimeoutException("The operation couldn't be completed due to a timeout.");
}
}
return(exportIteration);
}
/// <summary>
/// Consumes a line of data to populate a JobClass
/// </summary>
/// <param name="dataChunks">A collection of job class data points.</param>
/// <param name="jobClass">A JobClass object to consume the line data.</param>
/// <returns>Any remaining data after processing the JobClass.</returns>
IEnumerable<string> assignClassData(IList<string> dataChunks, JobClass jobClass)
{
//the process order here is important, since we're relying on simple(ish) Regex
//which may overlap one another
// 1. code is always 4 consecutive integers
string code = dataChunks.FirstOrDefault(c => FieldPatterns.ClassCode.IsMatch(c));
if (!String.IsNullOrEmpty(code))
{
jobClass.Code = code;
dataChunks.Remove(code);
}
// 2. grade is always 3 consecutive integers
string grade = dataChunks.FirstOrDefault(c => FieldPatterns.Grade.IsMatch(c));
if (!String.IsNullOrEmpty(grade))
{
jobClass.Grade = grade;
dataChunks.Remove(grade);
}
// 3. bargaining unit code is always 3 consecutive capital letters
string bu = dataChunks.FirstOrDefault(c => FieldPatterns.BargainingUnit.IsMatch(c));
if (!String.IsNullOrEmpty(bu))
{
jobClass.BargainingUnit =
bargainingUnits.ContainsKey(bu) ?
bargainingUnits[bu] : new BargainingUnit() { Name = string.Empty, Code = bu };
dataChunks.Remove(bu);
}
// 4. the remaining chunks are either part of the job title or part of a job step
// job step data is all numeric (integer or decimal numbers)
// so separate out the title parts and form the title
decimal dec;
var titleChunks = dataChunks.Where(c => !decimal.TryParse(c, out dec)).ToArray();
string title = String.Join(" ", titleChunks).Trim();
if (!String.IsNullOrEmpty(title))
{
jobClass.Title = title;
foreach (var chunk in titleChunks)
{
dataChunks.Remove(chunk);
}
}
//the job step chunks are all that should remain
return dataChunks;
}
public DefaultServerGridLayoutOptions(
ContextualizedHelpers helpers,
IList<RowType> rows,
IList<KeyValuePair<string, string>> toolbars,
Template<LayoutTemplateOptions> layoutTemplate,
IEnumerable<Template<LayoutTemplateOptions>> subTemplates,
IHtmlContent mainContent,
GridType type,
string id,
string prefix,
GridErrorMessages messages,
string cssClass,
string caption,
Type localizerType
) : base(rows, toolbars, layoutTemplate, subTemplates, mainContent)
{
this.helpers = helpers;
Type = type;
Messages = messages;
Id = id;
Prefix = prefix;
CssClass = cssClass;
Caption = caption;
var first = rows.FirstOrDefault();
MustAddButtonColumn = first.MustAddButtonColumn(helpers, Type== GridType.Batch);
VisibleColumns = first.VisibleColumns(helpers, Type == GridType.Batch);
LocalizerType = localizerType;
Localizer = LocalizerType != null ? helpers.LocalizerFactory.Create(LocalizerType) : null;
}
public static void IfParamDoesNotContain(RenderContext context, IList <object> arguments,
IDictionary <string, object> options,
RenderBlock fn, RenderBlock inverse)
{
var operation = arguments?.FirstOrDefault() as OpenApiOperation;
if (operation != null)
{
string name = null;
if (arguments.Count > 1)
{
name = arguments[1] as string;
}
var found = false;
foreach (var param in operation.Parameters)
{
if (param.Name == name)
{
found = true;
break;
}
}
if (!found)
{
fn(null);
}
}
}
public static void SetAccessControlHeaders(this IContext context, IList<IAccessControlEntry> accessControl)
{
if (accessControl == null || accessControl.Count == 0) return;
// For wildcards just add it
if (accessControl.Count == 1 && accessControl[0].Origin == "*")
{
context.Response.SetAccessControl(accessControl[0]);
return;
}
// If there's no Origin header in the request, no headers needed
var origin = context.Request.GetOrigin();
if (string.IsNullOrWhiteSpace(origin)) return;
// If origin and host match we don't need headers
var host = context.Request.Host;
if (new Uri(origin).Authority.Equals(host, StringComparison.OrdinalIgnoreCase)) return;
// Find a matching entry for the request origin
var entry = accessControl.FirstOrDefault(e => e.Origin.Equals(origin, StringComparison.OrdinalIgnoreCase));
if (entry != null)
{
context.Response.SetAccessControl(entry);
}
}
public AlgorithmManager(IPoolManager poolManager, IObjectFactory objectFactory)
{
_storage = new List<IHashAlgorithmStatistics>();
// add algorithms
foreach (var pool in poolManager.GetAll())
{
var query = _storage.FirstOrDefault(x => x.Name == pool.Config.Coin.Algorithm);
if (query != null)
continue;
var statistics = objectFactory.GetHashAlgorithmStatistics(pool.Config.Coin.Algorithm);
_storage.Add(statistics);
}
// assign pools to hash algorithms
foreach (var item in _storage)
{
var algorithm = item;
var pools = poolManager.GetAll().Where(p => p.Config.Coin.Algorithm == algorithm.Name);
algorithm.AssignPools(pools);
}
}
public bool CheckAllSecretQuestionAnswers(ILoginProcess process, IList<SecretQuestionAnswer> answers)
{
var session = EntityHelper.GetSession(process);
var context = session.Context;
bool result = true;
foreach(var qa in process.Login.SecretQuestionAnswers) {
var ans = answers.FirstOrDefault(a => a.QuestionId == qa.Question.Id);
if(ans == null)
result = false ; //question not answered
else
result &= CheckUserAnswer(qa, ans.Answer);
}
if(!result) {
process.FailCount++;
session.SaveChanges();
OnLoginEvent(context, LoginEventType.QuestionAnswersFailed, process.Login, "Secret questions check failed.");
LogIncident(context, LoginIncidentType, "InvalidQuestionAnswer",
"Invalid answer(s) to secret questions, user: "******",", process.Login.SecretQuestionAnswers.Select(qa => qa.Number));
process.PendingFactors &= ~ExtraFactorTypes.SecretQuestions;
session.SaveChanges();
OnLoginEvent(context, LoginEventType.QuestionAnswersSucceeded, process.Login, "Secret questions check succeeded.");
return result;
}
public void IfReturnType(RenderContext context, IList <object> arguments,
IDictionary <string, object> options,
RenderBlock fn, RenderBlock inverse)
{
var operation = arguments?.FirstOrDefault() as OpenApiOperation;
if (operation != null)
{
string type = null;
if (arguments.Count > 1)
{
type = arguments[1] as string;
}
var rt = GetReturnType(operation, "void");
if (type == "any" && rt != "void")
{
fn(null);
}
else if (string.Equals(type, rt.ToLower(), StringComparison.OrdinalIgnoreCase))
{
fn(null);
}
else if (type == "obj" && rt != "void" && rt != "Stream")
{
fn(null);
}
}
}
public void Delete(long id)
{
try
{
var record = _dataSet?.FirstOrDefault(x => x.Id == id);
if (record != null)
{
_dataSet.Remove(record);
}
}
catch (Exception)
{
throw;
}
}
private bool IncrimentCurrentOrder(IList <OrderContent> list, IOrderContent orderContent, bool isIncriment)
{
var a = list?.FirstOrDefault(x => x.IdProduct == orderContent.IdProduct);
if (a == null)
{
return(true);
}
if (isIncriment)
{
a.Quantity = (Convert.ToInt32(a.Quantity) + Convert.ToInt32(orderContent.Quantity)).ToString();
UserManager.Instance.UpdateUser(new UserModel {
Orders = list
});
}
else
{
if (a.Quantity == "1")
{
RemoveOrder(a.IdProduct);
}
else
{
a.Quantity = (Convert.ToInt32(a.Quantity) - Convert.ToInt32(orderContent.Quantity)).ToString();
UserManager.Instance.UpdateUser(new UserModel {
Orders = list
});
}
}
return(false);
}
/// <summary>
/// Gets a sorted shop list from JSON string in expected format
/// </summary>
/// <param name="json">the json string</param>
/// <returns>the shoplist</returns>
public static ShopList GetShopList(string json, List<Product> allProducts, Customer customer, IList<Supermarket> markets)
{
JObject jObject = JObject.Parse(json);
JToken jlistData = jObject["listData"];
JToken jmarketName = jObject["supermarket"];
string superName = jmarketName["superName"].ToString().Trim();
Supermarket market = markets.FirstOrDefault(m => m.Name == superName) ?? markets[0];
JToken jlistItems = jlistData["listItems"];//jlistData.First;
var AllItems = jlistItems.Where(token => token.HasValues).ToList();//jlistItems.Children()[1];//.FirstOrDefault()["Id"];
int temp;
var tuplesStr =
AllItems.OfType<JObject>()
.Cast<IDictionary<string, JToken>>() //easier to handle as dictionary
.Where(i => i.ContainsKey("Id") && i["Id"] !=null && !String.IsNullOrWhiteSpace(i["Id"].ToString())) //make sure ID is available
.Select(i => new Tuple<string, string>( i["Id"].ToString() , i.ContainsKey("Quantity") ? i["Quantity"].ToString() : "1"))//get tuple with ID / quantity
.Where(t => int.TryParse(t.Item1, out temp) && int.TryParse(t.Item2, out temp))//parse to int
.ToList();//list is easier to debug
var quantityByProductDic= new Dictionary<Product,int>();
//add products to dictionary
tuplesStr.ToList()
.ForEach(t => quantityByProductDic.Add(allProducts.FirstOrDefault(p => p.Id == int.Parse(t.Item1)), int.Parse(t.Item2)));
ShopList sl = Logics.GetShoppingList(quantityByProductDic, market, customer);
return sl;
}
private bool PlayerHaveOpponents(JogadorHistorico player, IEnumerable <JogadorHistorico> team)
{
var opponent = _listaPartidas?.FirstOrDefault(x => x.ClubeCasaId == player.ClubeId && x.Rodada == player.RodadaId + 1)?.ClubeVisitanteId ??
_listaPartidas.FirstOrDefault(x => x.ClubeVisitanteId == player.ClubeId && x.Rodada == player.RodadaId + 1).ClubeCasaId;
return(team.Any(x => x.ClubeId == opponent));
}
public void MatchPlayers(IList<FantasyProsPlayer> players, IList<DraftKingsPlayer> draftKingsPlayers)
{
IList<string> teams = new List<string>();
IList<FantasyProsPlayer> unMatchedPlayers = new List<FantasyProsPlayer>();
foreach (FantasyProsPlayer player in players) {
DraftKingsPlayer matchingDraftKingsPlayer = draftKingsPlayers.FirstOrDefault(dk => dk.Name.ToLower() == player.PlayerName.ToLower());
if (matchingDraftKingsPlayer == null) {
if (!teams.Contains(player.Team)) {
teams.Add(player.Team);
}
unMatchedPlayers.Add(player);
continue;
}
player.DraftKingsPlayer = matchingDraftKingsPlayer;
}
foreach (string team in teams) {
Console.WriteLine(team);
foreach (var player in unMatchedPlayers.Where(p => p.Team == team)) {
Console.WriteLine(player.PlayerName);
}
}
}
private void ConfirmPackList(TradevineGateway gateway, IList<Messages.SalesOrder> salesOrders, Dictionary<string, int> headerIndexes, List<string> row)
{
string packListID = string.Empty;
try
{
packListID = row[headerIndexes["PackListID"]];
packListID = packListID.Replace("ID:", string.Empty);
var id = !string.IsNullOrEmpty(packListID) ? long.Parse(packListID) : (long?)null;
var courier = row[headerIndexes["Courier"]];
var trackingReference1 = row[headerIndexes["TrackingReference1"]];
var trackingReference2 = row[headerIndexes["TrackingReference2"]];
var salesOrder = salesOrders.FirstOrDefault(x => x.PackLists.Any(y => y.PackListID == id));
if (null == salesOrder)
return;
var packList = salesOrder.PackLists.Single(x => x.PackListID == id);
packList.Courier = !string.IsNullOrEmpty(courier) ? int.Parse(courier) : (int?)null;
packList.TrackingReference = trackingReference1;
packList.TrackingReference2 = trackingReference2;
packList.ConfirmOptions = new Messages.ConfirmOptions() { IsInvoiceEmailed = true, IsPackingSlipEmailed = true };
var output = gateway.Sales.ConfirmPackList(packList);
Console.WriteLine("Packlist {0} now has status {1}", output.PackListNumber, output.Status);
}
catch (Exception ex)
{
Console.WriteLine("Error confirming packlist {0} : {1} : {2}", packListID, ex.Message, ex.StackTrace);
}
}
public JwtAuthResult GenerateTokens(long userId, string username, IList <Claim> claims, DateTime now)
{
var shouldAddAudienceClaim = string.IsNullOrWhiteSpace(claims?.FirstOrDefault(x => x.Type == JwtRegisteredClaimNames.Aud)?.Value);
var jwtToken = new JwtSecurityToken(
_jwtTokenConfig.Issuer,
shouldAddAudienceClaim ? _jwtTokenConfig.Audience : string.Empty,
claims,
expires: now.AddMinutes(_jwtTokenConfig.AccessTokenExpiration),
signingCredentials: new SigningCredentials(new SymmetricSecurityKey(_secret), SecurityAlgorithms.HmacSha256Signature));
var accessToken = new JwtSecurityTokenHandler().WriteToken(jwtToken);
var refreshToken = new RefreshToken
{
UserId = userId,
TokenString = GenerateRefreshTokenString(),
ExpireAt = now.AddMinutes(_jwtTokenConfig.RefreshTokenExpiration)
};
_usersRefreshTokens.AddOrUpdate(refreshToken.TokenString, refreshToken, (s, t) => refreshToken);
return(new JwtAuthResult
{
AccessToken = accessToken,
RefreshToken = refreshToken
});
}
/// <summary>
/// Find the node that's closest to the source node.
/// </summary>
/// <param name="source">The source node.</param>
/// <param name="sharedParentNode">The parent node in common between the node in question and all the nodes in the list.</param>
/// <param name="nodes">A list of nodes where we want to determine the closest to the source.</param>
/// <returns>The node that is closest to the source.</returns>
public static HtmlNode FindClosestNode(this HtmlNode source, HtmlNode sharedParentNode, IList<HtmlNode> nodes)
{
if (nodes.Count < 2) // don't even bother.
{
return nodes.FirstOrDefault();
}
int index = source.GetParentNodeUntil(sharedParentNode).GetIndex(); // get the index of our node, relative to the shared parent node.
HtmlNode closest = null;
int distance = int.MaxValue;
foreach (HtmlNode currentNode in nodes)
{
int currentIndex = currentNode.GetParentNodeUntil(sharedParentNode).GetIndex(); // get the index of this node, relative to the shared parent node.
int currentDistance;
if (currentIndex > index)
{
currentDistance = currentIndex - index;
}
else
{
currentDistance = index - currentIndex;
}
if (currentDistance < distance)
{
closest = currentNode;
distance = currentDistance;
}
}
return closest;
}
public static string GetCSName( this ParamFunctionOption paramFunctionOption, IList<TypeMap> typeMapList, IList<CSTypeMap> csTypeMapList,
IList<EnumData> enumDatas)
{
CSTypeMap csTypeMap;
TypeMap typeMap;
GetTypeMap( typeMapList, csTypeMapList, out csTypeMap, out typeMap, paramFunctionOption.ParamType,
paramFunctionOption is ArrayParamFunctionOption );
if (csTypeMap.Attributes.Contains( "enum" ))
{
if (enumDatas.FirstOrDefault(data => data.Name == paramFunctionOption.ParamType) != null)
return paramFunctionOption.ParamType;
}
if (csTypeMap.LanguageName == "void")
{
return "void" + new string( '*', typeMap.LanguageName.PointDeep +
(paramFunctionOption is ArrayParamFunctionOption ? 1 : 0) );
}
if (paramFunctionOption is ArrayParamFunctionOption &&
(paramFunctionOption.ParamType == "charARB" || paramFunctionOption.ParamType == "char") &&
paramFunctionOption.Direction == "out")
{
return "char[]";
}
if (paramFunctionOption is ArrayParamFunctionOption && csTypeMap.LanguageName == "string" && paramFunctionOption.ParamType != "charPointerARB")
{
return "string";
}
return csTypeMap.LanguageName + new string( '*', typeMap.LanguageName.PointDeep > 0 ? typeMap.LanguageName.PointDeep : 0 ) +
(paramFunctionOption is ArrayParamFunctionOption ? "[]" : "");
}
public void ApplyLoadshopFee(string usersPrimaryScac, ILoadFeeData load, IList <CustomerEntity> customers)
{
// get the customer
var customer = customers?.FirstOrDefault(_ => load.CustomerId == _.CustomerId);
if (customer == null)
{
throw new Exception("Customer not found");
}
var inNetwork = customer.CustomerCarrierScacContracts?.Any(_ => _.Scac == (load.Scac ?? usersPrimaryScac)) ?? false;
var flatFee = inNetwork ? customer.InNetworkFlatFee : customer.OutNetworkFlatFee;
var percentFee = inNetwork ? customer.InNetworkPercentFee : customer.OutNetworkPercentFee;
var feeAdd = inNetwork ? customer.InNetworkFeeAdd : customer.OutNetworkFeeAdd;
var fee = flatFee + Math.Round(percentFee * (load.LineHaulRate + load.FuelRate), 2, MidpointRounding.AwayFromZero);
if (!feeAdd)
{
load.LineHaulRate -= fee;
}
load.FeeData = new LoadshopFeeData
{
LoadshopFlatFee = flatFee,
LoadshopPercentFee = percentFee,
LoadshopFee = fee,
LoadshopFeeAdd = feeAdd
};
}
public string GetNestingParent(string potentialChildFilePath, string potentialChildDirectory, IList<string> potentialParentProjectItems)
{
string fileName = Path.GetFileName(potentialChildFilePath);
if (fileName != ".bowerrc") return null;
return potentialParentProjectItems.FirstOrDefault(x => x == "bower.json");
}
public PearsonCorrelationGroupDescription(
IList<VariableDescription> variables,
IList<VariableDescription> targetVariables)
: base(variables, targetVariables.FirstOrDefault())
{
TargetVariables = targetVariables;
}
public int Run(IList<string> args)
{
string command = args.FirstOrDefault() ?? "";
_stdout.WriteLine("executing subtree " + command);
if (string.IsNullOrEmpty(Prefix))
{
_stdout.WriteLine("Prefix must be specified, use -p or -prefix");
return GitTfsExitCodes.InvalidArguments;
}
switch (command.ToLower())
{
case "add":
return DoAdd(args.ElementAtOrDefault(1) ?? "", args.ElementAtOrDefault(2) ?? "");
case "pull":
return DoPull(args.ElementAtOrDefault(1));
case "split":
return DoSplit();
default:
_stdout.WriteLine("Expected one of [add, pull, split]");
return GitTfsExitCodes.InvalidArguments;
}
}
/// <inheritdoc/>
public async override Task <string> RetrieveSerializedEntityState(EntityId entityId, JsonSerializerSettings serializerSettings)
{
var instanceId = EntityId.GetSchedulerIdFromEntityId(entityId);
IList <OrchestrationState> stateList = await this.serviceClient.GetOrchestrationStateAsync(instanceId, false);
OrchestrationState state = stateList?.FirstOrDefault();
if (state != null &&
state.OrchestrationInstance != null &&
state.Input != null)
{
string serializedState;
if (state.Input.StartsWith("http"))
{
serializedState = await this.serviceClient.DownloadBlobAsync(state.Input);
}
else
{
serializedState = state.Input;
}
var schedulerState = JsonConvert.DeserializeObject <SchedulerState>(serializedState, serializerSettings);
if (schedulerState.EntityExists)
{
return(schedulerState.EntityState);
}
}
return(null);
}
public PartialViewResult EditContactClosedFilter(IList<ContactFilter> filters, ContactClosedFilter filter)
{
filters.Remove(filters.FirstOrDefault(cf => cf.Id == filter.Id));
filters.Add(filter);
return PartialView("DisplayTemplates/contactClosedFilter", filter);
}
public Attachment CreateBatonsAttachment(IList <FirebaseObject <BatonQueue> > batons)
{
// combine path for cross platform support
string[] paths = { ".", "Resources", "batonQueue.json" };
var adaptiveCardJson = File.ReadAllText(Path.Combine(paths));
var listBuilder = new StringBuilder();
var headerBuilder = new StringBuilder();
var commentBuilder = new StringBuilder();
foreach (var baton in batonList.GetBatons())
{
//Get the batonqueue
var batonQueue = batons?.FirstOrDefault(x => x.Object.Name == baton.Shortname);
listBuilder.Append(FormatQueue(batonQueue?.Object));
headerBuilder.Append(FormatHeader(batonQueue?.Object));
commentBuilder.Append(FormatComments(batonQueue?.Object));
}
adaptiveCardJson = adaptiveCardJson.Replace("\"{QueueData}\"", listBuilder.ToString());
adaptiveCardJson = adaptiveCardJson.Replace("\"{HeaderData}\"", headerBuilder.ToString());
adaptiveCardJson = adaptiveCardJson.Replace("\"{CommentsData}\"", commentBuilder.ToString());
var adaptiveCardAttachment = new Attachment()
{
ContentType = "application/vnd.microsoft.card.adaptive",
Content = JsonConvert.DeserializeObject(adaptiveCardJson),
};
return(adaptiveCardAttachment);
}
public ExtendedServiceBusNamespace(
ServiceBusNamespace serviceBusNamespace,
IList<NamespaceDescription> descriptions)
{
Name = serviceBusNamespace.Name;
Region = serviceBusNamespace.Region;
Status = serviceBusNamespace.Status;
CreatedAt = serviceBusNamespace.CreatedAt;
AcsManagementEndpoint = serviceBusNamespace.AcsManagementEndpoint != null ? serviceBusNamespace.AcsManagementEndpoint.ToString() : string.Empty;
ServiceBusEndpoint = serviceBusNamespace.ServiceBusEndpoint != null ? serviceBusNamespace.ServiceBusEndpoint.ToString() : string.Empty;
if (descriptions != null && descriptions.Count != 0)
{
NamespaceDescription desc = descriptions.FirstOrDefault();
DefaultKey = this.GetKeyFromConnectionString(desc.ConnectionString);
ConnectionString = desc.ConnectionString;
}
else
{
DefaultKey = string.Empty;
ConnectionString = string.Empty;
}
}
void NonKeywordAttrError(IList<LNode> attrs, string stmtType)
{
var attr = attrs.FirstOrDefault(a => a.AttrNamed(S.TriviaWordAttribute) != null);
if ((attr != null)) {
Error(attr, "'{0}' appears to be a word attribute, which is not permitted before '{1}'", attr.Range.SourceText, stmtType);
}
}
public IList <ControlResult> Evaluate(IList <ResourceControlSet> resourceControlSets, JObject resource)
{
var type = resource.GetValueCaseInsensitive <string>("type");
//var apiVersion = resource.GetValueCaseInsensitive<string>("apiVersion");
var controlSet = resourceControlSets?.FirstOrDefault(
x => x.supportedResourceTypes.Any(y => y.Equals(type, StringComparison.OrdinalIgnoreCase)));
if (controlSet == null)
{
return(new List <ControlResult> {
ControlResult.NotSupported(resource)
});
}
var results = new List <ControlResult>();
foreach (var control in controlSet.Controls)
{
control.FeatureName = controlSet.FeatureName;
control.SupportedResources = controlSet.supportedResourceTypes.ToArray().ToSingleString(" , ");
var controlResult = _controlEvaluator.Evaluate(control, resource);
results.Add(controlResult);
}
EvaluateNestedResources(controlSet, resource, results);
return(results);
}
/// <summary>
/// Converts a timestamp specified in seconds/nanoseconds to a string.
/// </summary>
/// <remarks>
/// If the value is a normalized duration in the range described in <c>field_mask.proto</c>,
/// <paramref name="diagnosticOnly"/> is ignored. Otherwise, if the parameter is <c>true</c>,
/// a JSON object with a warning is returned; if it is <c>false</c>, an <see cref="InvalidOperationException"/> is thrown.
/// </remarks>
/// <param name="paths">Paths in the field mask</param>
/// <param name="diagnosticOnly">Determines the handling of non-normalized values</param>
/// <exception cref="InvalidOperationException">The represented duration is invalid, and <paramref name="diagnosticOnly"/> is <c>false</c>.</exception>
internal static string ToJson(IList<string> paths, bool diagnosticOnly)
{
var firstInvalid = paths.FirstOrDefault(p => !ValidatePath(p));
if (firstInvalid == null)
{
var writer = new StringWriter();
JsonFormatter.WriteString(writer, string.Join(",", paths.Select(JsonFormatter.ToCamelCase)));
return writer.ToString();
}
else
{
if (diagnosticOnly)
{
var writer = new StringWriter();
writer.Write("{ \"@warning\": \"Invalid FieldMask\", \"paths\": ");
JsonFormatter.Default.WriteList(writer, (IList)paths);
writer.Write(" }");
return writer.ToString();
}
else
{
throw new InvalidOperationException($"Invalid field mask to be converted to JSON: {firstInvalid}");
}
}
}
private Type GetMatchingFilter(Property property, IList<Type> filters)
{
var filterType = filters.FirstOrDefault(x => x.BaseType.GetGenericArguments()[0] == property.TypeInfo.NotNullableType);
if (filterType != null)
return filterType;
filterType = filters.FirstOrDefault(x => x.BaseType.GetGenericArguments()[0].IsAssignableFrom(property.TypeInfo.NotNullableType));
if (filterType != null)
return filterType;
var groupers = filters.Where(x => typeof(ITypeGrouper).IsAssignableFrom(x.BaseType.GetGenericArguments()[0])).ToList();
if (groupers.IsNullOrEmpty() == false)
return groupers.FirstOrDefault(x => CreateTypeGrouperInstance(x.BaseType.GetGenericArguments()[0]).Match(property.TypeInfo.NotNullableType));
return null;
}
public IList <ControlResult> Evaluate(IList <ResourceControlSet> resourceControlSets, List <ResourceModel> resources)
{
var featureName = resources?.First().FeatureName;
var controlSet = resourceControlSets?.FirstOrDefault(x => x.FeatureName.Equals(featureName, StringComparison.OrdinalIgnoreCase));
var results = new List <ControlResult>();
foreach (var control in controlSet.Controls)
{
List <string> resourcePathList = new List <string>();
ControlResult controlResult = null;
foreach (var resource in resources)
{
controlResult = _controlEvaluator.Evaluate(control, resource.Resource);
resourcePathList.Add(controlResult.ResourceDataMarker.JsonPath);
if (!controlResult.IsTokenNotFound)
{
break;
}
}
if (controlResult != null)
{
if (controlResult.IsTokenNotFound)
{
controlResult.ResourceDataMarker.JsonPath = resourcePathList.ToArray().ToSingleString(" , ");
}
results.Add(controlResult);
}
}
foreach (var resource in resources)
{
EvaluateNestedResources(controlSet, resource.Resource, results);
}
return(results);
}
/// <summary>
/// Applies Annotations to a list of PdfColumnAttributes.
/// </summary>
/// <param name="bodyDataSource">Data source</param>
/// <param name="result">A list of PdfColumnAttributes</param>
/// <param name="areColumnsAdHoc">It's possible to remove the MainTableColumns part completely</param>
public static void ApplyPropertyDataAnnotations(this IDataSource bodyDataSource, IList<ColumnAttributes> result, bool areColumnsAdHoc = false)
{
var properties = bodyDataSource.GetPropertiesInfoOfStronglyTypedListDataSource();
if (properties == null || !properties.Any()) return;
var fieldsInfo = bodyDataSource.GetFieldsInfoOfStronglyTypedListDataSource();
foreach (var property in properties)
{
var columnAttributes = result.FirstOrDefault(x => x.PropertyName == property.Name);
if (columnAttributes == null) continue;
applyPropertyName(property, columnAttributes, areColumnsAdHoc);
applyAggregateFunction(property, columnAttributes);
applyFixedHeight(property, columnAttributes);
applyMinimumHeight(property, columnAttributes);
applyCellsHorizontalAlignment(property, columnAttributes);
applyColumnIsVisible(property, columnAttributes);
applyOrder(property, columnAttributes);
applyWidth(property, columnAttributes);
applyDataFormatString(property, columnAttributes);
applyColumnItemsTemplate(property, columnAttributes);
applyCalculatedField(property, columnAttributes, fieldsInfo);
applyIncludedGroupFieldEqualityComparer(property, columnAttributes, fieldsInfo);
}
}
public ProcessingDialogViewModel()
{
LoadParameters = new DelegateCommand<MassSpecStudio.Core.Domain.Algorithm>(OnLoadParameters);
_algorithms = ServiceLocator.Current.GetAllInstances<IAlgorithm>().ToList();
_selectedAlgorithm = _algorithms.FirstOrDefault();
_recentAlgorithmsUsed = RecentAlgorithms.Read();
}
public static IList <StudentPanoramaCalendarViewData> Create(IList <StudentAbsenceInfo> absences, IList <StudentInfractionInfo> studentInfractions
, IList <Date> allSchoolDays, IEnumerable <SchoolYear> schoolYears)
{
var res = new List <StudentPanoramaCalendarViewData>();
schoolYears = schoolYears.OrderByDescending(sy => sy.AcadYear);
foreach (var schoolYear in schoolYears)
{
var syDays = allSchoolDays.Where(sy => sy.SchoolYearRef == schoolYear.Id);
var items = syDays.Select(day =>
{
var absence = absences?.FirstOrDefault(a => a.Date == day.Day);
var dayInfractions = studentInfractions?.Where(i => i.OccurrenceDate == day.Day).ToList();
return(StudentPanoramaCalendarItemViewData.Create(absence, dayInfractions, day));
}).ToList();
res.Add(new StudentPanoramaCalendarViewData
{
AcadYear = schoolYear.AcadYear,
SchoolYearName = schoolYear.Name,
SchoolYearId = schoolYear.Id,
CalendarItems = items
});
}
return(res);
}
/// <summary>
/// Calculates total word score
/// </summary>
/// <param name="word"></param>
/// <returns></returns>
public async Task <Score> CalculateScoreAsync(string word)
{
if (string.IsNullOrWhiteSpace(word))
{
return(new Score(word, "Word is blank."));
}
if (word.Length == 2)
{
return(new Score(word, $"\"{word}\" was skipped."));
}
word = word.Trim().ToUpper();
IList <WordDefinitionsSyllablesPartsOfSpeech> result = await _wordLookup.GetWordDefinitionSyllableCountAsync(word);
WordDefinitionsSyllablesPartsOfSpeech firstResult = result?.FirstOrDefault();
if (word != firstResult?.Word?.ToUpper())
{
return(new Score(word, $"\"{word}\" is not found in the dictionary."));
}
if (IsProperNoun(firstResult.PartsOfSpeech))
{
return(new Score(word, $"\"{word}\" is a proper noun."));
}
int pointsPerLetter = CalculatePointsPerLetter(word);
int extraPoints = CalculateExtraPoints(word);
var syllablePoints = (int)firstResult?.NumSyllables;
int doubleLetterPoints = CalculateDoubleLetterPoints(word);
var score = new Score(word, pointsPerLetter, extraPoints, syllablePoints, doubleLetterPoints, 0);
return(score);
}
public Config(ScenarioTypeAttribute scenario
, ImplementationTypeAttribute implementation
, uint runs, ScenarioTypeAttribute[] knownScenarios
, ImplementationTypeAttribute[] knownImplementations
, IList<TypeLocator> perfTests
, string pluginPath)
{
Scenario = scenario;
Implementation = implementation;
Runs = runs;
KnownScenarios = knownScenarios;
KnownImplementations = knownImplementations;
PerfTests = perfTests;
PluginPath = pluginPath;
Groups = new Dictionary<ScenarioTypeAttribute, IDictionary<ImplementationTypeAttribute, TypeLocator>>();
foreach (var knownScenario in KnownScenarios)
{
var inner = new Dictionary<ImplementationTypeAttribute, TypeLocator>();
foreach (var knownImplementation in KnownImplementations)
{
inner[knownImplementation] = perfTests.FirstOrDefault(pt => pt.Attributes.Contains(knownImplementation) && pt.Attributes.Contains(knownScenario));
}
Groups[knownScenario] = inner;
}
}
private string GetInternalLoadBalancerIPAddress(IList<VirtualIPAddress> virtualIPs, string ilbName)
{
var ilbIP = virtualIPs == null || !virtualIPs.Any() ? null
: virtualIPs.FirstOrDefault(ip => string.Equals(ip.Name, ilbName, StringComparison.OrdinalIgnoreCase));
return ilbIP == null ? null : ilbIP.Address;
}
private void CheckAllTables(IDataTable[] tables, Migration mode, Boolean dbExit)
{
// 数据库表进入字典
//var dic = new Dictionary<String, IDataTable>(StringComparer.OrdinalIgnoreCase);
IList <IDataTable> dbtables = null;
if (dbExit)
{
dbtables = OnGetTables(tables.Select(t => t.TableName).ToArray());
//if (dbtables != null && dbtables.Count > 0)
//{
// foreach (var item in dbtables)
// {
// //dic.Add(item.TableName, item);
// dic[item.TableName] = item;
// }
//}
}
foreach (var item in tables)
{
try
{
// 在MySql中，可能存在同名表（大小写不一致），需要先做确定查找，再做不区分大小写的查找
var dbtable = dbtables?.FirstOrDefault(e => e.TableName == item.TableName);
if (dbtable == null)
{
dbtable = dbtables?.FirstOrDefault(e => e.TableName.EqualIgnoreCase(item.TableName));
}
// 判断指定表是否存在于数据库中，以决定是创建表还是修改表
//if (dic.TryGetValue(item.TableName, out var dbtable))
if (dbtable != null)
{
CheckTable(item, dbtable, mode);
}
else
{
CheckTable(item, null, mode);
}
}
catch (Exception ex)
{
WriteLog(ex.ToString());
}
}
}
static bool HandleLines(IList<string> lines, Market market, char[] seps, StringBuilder sb)
{
//Read First Line to fin Vol Surface and if its Rho or Nu
bool isRho = true;
InterestVolatility vol = null;
var firstLine = lines.FirstOrDefault();
if (string.IsNullOrEmpty(firstLine))
{
sb.Append("Cannot parse first line");
return false;
}
var ss = firstLine.Split(seps);
var sdate = ss[2];
var stype = ss[3];
var ticker = ss[4];
var date = SimpleDate.Parse(sdate);
isRho = stype.ToUpper().Contains("RHO");
var isBeta = stype.ToUpper().Contains("BETA");
ss = ticker.Split('.');
var name = ss[0];
var ccy = ss[1];
var time = date.ToDateTime(23, 59, 59);
market.Time = time;
market.ClearMarketDatas();
var vols = market.GetAll(true, false, false, true, false, false, false, false, false, false, false, false, false);
foreach (var im in vols)
{
var ivol = im as InterestVolatility;
if (ivol != null && ivol.Currency.Equals(ccy))
{
vol = ivol;
break;
}
}
if (vol == null)
{
sb.Append("Cannot Find Any Vol for " + ticker);
return false;
}
var output = vol.Output as InterestVolatilityOutput;
if (output == null)
{
sb.Append("Invalid Vol not built " + vol);
return false;
}
var data = new List<SabrData>();
foreach (var line in lines)
{
var d = new SabrData();
ss = line.Split(seps);
var tick = ss[4];
d.Date = SimpleDate.Parse(ss[2]).ToDateTime();
d.ComponentTicker = tick;
d.InstrumentType = ss[3];
d.Value = Convert.ToDouble(ss[5]);
data.Add(d);
}
return HandleData(vol, isRho, isBeta, data, market, sb);
}
public string GetImageUrl(IList <ImageItem> images)
{
var image = images?
.FirstOrDefault();
var imageUrl = image?.PathMini;
return(imageUrl);
}
protected void Reset()
{
IChannelGroup channelGroup = ChannelGroup;
if (channelGroup == null)
{
ChannelGroup = _channelGroups.FirstOrDefault();
}
Channel = _channels?.FirstOrDefault();
RecordingType = ScheduleRecordingType.Once;
DateTime now = DateTime.Now;
DateTime start = new DateTime(now.Year, now.Month, now.Day, now.Hour, now.Minute, 0, now.Kind);
StartTime = start;
EndTime = start.AddHours(1);
}
private CalendarPropertyParameter FindParameter(string paramName)
{
if (paramName == null)
{
throw new ArgumentNullException(nameof(paramName));
}
paramName = paramName.ToLowerInvariant();
return(Parameters?.FirstOrDefault(item => item.Name?.ToLowerInvariant() == paramName));
}
public async Task <IGamePlugin> GetActiveGamePluginAsync()
{
if (_activeGamePlugins == null)
{
await ReloadGamesAsync();
}
return(_activeGamePlugins?.FirstOrDefault(plugin => plugin.IsRunning()));
}
internal static IAuthenticator ConvertToAuthenticator(IList <IAuthenticatorValue> authenticators, IAuthenticatorEnrollment authenticatorEnrollment)
=> new Authenticator
{
Id = authenticators?.FirstOrDefault(x => x.Key == authenticatorEnrollment.Key)?.Id,
Name = authenticatorEnrollment.DisplayName,
MethodTypes = authenticatorEnrollment.Methods?.Select(x => x.Type).ToList(),
EnrollmentId = authenticatorEnrollment.Id,
Profile = GetAuthenticatorProfile(authenticatorEnrollment),
};
public override void UpdateForEachOutputs(IList <Tuple <string, string> > updates)
{
var itemUpdate = updates?.FirstOrDefault(tuple => tuple.Item1 == Result);
if (itemUpdate != null)
{
Result = itemUpdate.Item2;
}
}
static XAttribute GetNotNull (IList<ParameterAnnotation> annotations, int parameterIndex)
{
var ann = annotations?.FirstOrDefault (a => a.ParameterIndex == parameterIndex)?.Annotations;
if (ann?.Any (a => IsNotNullAnnotation (a)) == true)
return new XAttribute ("not-null", "true");
return null;
}
public bool MoveTo(TextAdventureState nextState)
{
if (States?.FirstOrDefault(state => state?.Id == nextState?.Id) == null)
{
return(false);
}
if (nextState?.RequiredItem != null && !_inventory.Contains(nextState?.RequiredItem))
{
BlockedTransition = true;
return(false);
}
if (_stateMachine.MoveTo(nextState))
{
_inventory.Add(CurrentState.AcquiredItem);
return(true);
}
return(false);
}
static string ToImageUrl(IList <CardImage> images)
{
var firstImage = images?.FirstOrDefault();
if (firstImage == null)
{
return(null);
}
return(firstImage.Url);
}
public static string ResolveFullTypeName(IList <CssNamespace> namespaces, string cssTypeExpression)
{
string typename;
if (cssTypeExpression.IndexOf('|') > -1)
{
var strs = cssTypeExpression.Split('|');
var alias = strs[0];
var shortTypename = strs[1];
var namespaceUri = namespaces
?.FirstOrDefault(x => x.Alias == alias)
?.Namespace ?? namespaceMapping.First().Key;
namespaceUri = EnsureAssemblyQualifiedName(namespaceUri, shortTypename);
var namespaceFragments = namespaceUri
.Split(separator, 2);
if (namespaceFragments == null)
{
throw new Exception($@"Namespace ""{alias}"" not found!");
}
typename = $"{namespaceFragments[0]}.{shortTypename},{string.Join(",", namespaceFragments.Skip(1))}";
}
else
{
var strs = cssTypeExpression.Split('.');
var shortTypename = strs[0];
var namespaceUri = namespaces
?.FirstOrDefault(x => x.Alias == "")
?.Namespace ?? namespaceMapping.First().Key;
var namespaceFragments = EnsureAssemblyQualifiedName(namespaceUri, shortTypename)
.Split(separator, 2);
typename = $"{namespaceFragments[0]}.{strs[0]},{string.Join(",", namespaceFragments.Skip(1))}";
}
return(typename);
}
public static void MyRemove(this IList <string> list, string value, StringComparison comparison = StringComparison.OrdinalIgnoreCase)
{
var theOne = list?.FirstOrDefault(x => x.MyEquals(value, comparison));
if (theOne == null)
{
return;
}
list.Remove(theOne);
}
private GdbWorkspace GetWorkspace([NotNull] DdxModel model)
{
// TODO: In case it is needed before InitializeSchema() is called, allow creation of
// a 'lazy' workspace that is just an empty container that gets initialized
// with datasets from remote only when necessary.
GdbWorkspace workspace =
_virtualWorkspaces?.FirstOrDefault(w => w.WorkspaceHandle == model.Id);
return(workspace);
}
