public void Initialize()
{
order = new Order();
order.OrderEntries = null;
order.SentDate = DateTime.Now;
order.Id = 10;
order.User = null;
userAcc = new UserAccount();
userAcc.Id = 5;
orders = new List<Order>();
orderManagementDaoMock = _factory.CreateMock<IOrderManagementDao>();
oms.OrderManagementDao = orderManagementDaoMock.MockObject;
// NMock.Actions.InvokeAction saveOrder = new NMock.Actions.InvokeAction(new Action(() => orders = new List<Order>(){order}));
// orderManagementDaoMock.Expects.Any.MethodWith(x => x.SaveOrUpdate(order)).Will(saveOrder);
orderInformationDaoMock = _factory.CreateMock<IOrderInformationsDao>();
ois.OrderInformationDao = orderInformationDaoMock.MockObject;
orderInformationDaoMock.Expects.Any.MethodWith<Order>(x => x.GetOrderById(order.Id)).WillReturn(order);
orderInformationDaoMock.Expects.Any.MethodWith<Order>(x => x.GetOrderById(-1)).WillReturn(null);
// orderInformationDaoMock.Expects.Any.MethodWith(x => x.GetOrdersByUserId(userAcc.Id)).WillReturn(orders.Where(x => x.User.Id == userAcc.Id));
orderInformationDaoMock.Expects.Any.MethodWith(x => x.GetOrdersByUserId(-1)).WillReturn(orders.Where(x => x.User.Id == userAcc.Id));
orderInformationDaoMock.Expects.Any.Method(x => x.GetUndeliveredOrders()).WillReturn(orders.Where(x => x.Status != Order.OrderState.DELIVERED));
orderInformationDaoMock.Expects.Any.MethodWith(x => x.GetUndeliveredByUserId(userAcc.Id)).WillReturn(orders.Where(x => x.Status != Order.OrderState.DELIVERED && x.User.Id == userAcc.Id));
//orderInformationDaoMock.Expects.Any.MethodWith(x => x.GetDeliveredOrdersByUserId(userAcc.Id)).WillReturn(orders.Where(x => x.Status == Order.OrderState.DELIVERED && x.User.Id == userAcc.Id));
}
public ComponentInfo(string id, Type serviceType, Type componentType, IList<IPolicy> policies, bool lifeManagement)
{
id.ThrowIfNullArgument(nameof(id));
_id = id;
_serviceType = serviceType;
_componentType = componentType;
if (_serviceType == null && _componentType == null)
ExceptionHelper.ThrowInfoNotComplete(_id);
_lifecycleManagement = lifeManagement;
_buildPolicies = new List<IPolicy>();
var preCreation = policies.Where(p => p.Stage == Stages.PreCreation).ToArray();
if (preCreation.Length == 0)//If no policy define for PreCreation, stateless will be default policy
_buildPolicies.Add(new StatelessPolicy());
else
_buildPolicies.AddRange(preCreation);
var creation = policies.Where(p => p.Stage == Stages.Creation).ToArray();
if (creation.Length == 0)//If no policy define for Creation, activator will be default policy
_buildPolicies.Add(new ActivatorPolicy());
else
_buildPolicies.AddRange(creation);
_buildPolicies.AddRange(policies.Where(p => p.Stage == Stages.Initialization || p.Stage == Stages.PostInitialization));
}
public override bool Upgrade(PackageSession session, ILogger log, Package dependentPackage, PackageDependency dependency, Package dependencyPackage, IList<PackageLoadingAssetFile> assetFiles)
{
// Paradox 1.1 projects didn't have their dependency properly updated (they might have been marked as 1.0).
// We know they are 1.1 only because there is a .props file.
// This check shouldn't be necessary from 1.2.
var packagePath = dependentPackage.FullPath;
var propsFilePath = UPath.Combine(packagePath.GetParent(), (UFile)(packagePath.GetFileName() + ".props"));
if (!File.Exists(propsFilePath) && dependency.Version.MinVersion < new PackageVersion("1.1.0-beta"))
{
log.Error("Can't upgrade old projects from {0} 1.0 to 1.1", dependency.Name);
return false;
}
// Nothing to do for now, most of the work is already done by individual asset upgraders
// We can later add logic here for package-wide upgrades (i.e. GameSettingsAsset)
if (dependency.Version.MinVersion < new PackageVersion("1.2.0-beta"))
{
// UIImageGroups and SpriteGroups asset have been merged into a single SpriteSheet => rename the assets and modify the tag
var uiImageGroups = assetFiles.Where(f => f.FilePath.GetFileExtension() == ".pdxuiimage");
var spitesGroups = assetFiles.Where(f => f.FilePath.GetFileExtension() == ".pdxsprite");
RenameAndChangeTag(assetFiles, uiImageGroups, "!UIImageGroup");
RenameAndChangeTag(assetFiles, spitesGroups, "!SpriteGroup");
}
return true;
}
public ICard HighestCard(IList<ICard> cards)
{
//TODO use aggregates instead:
//ICard highestTrumpCard =
// _Cards.Where(a => a.Suit == _Trump).Aggregate(card,
// (curMin, x) =>
// (x.Rank > curMin.Rank ? x : curMin));
var trumpCards = cards.Where(a => a.Suit == _Trump).ToList();
if (trumpCards.Any())
{
ICard highestTrumpCard = trumpCards[0];
foreach (var card in trumpCards)
{
if (card.Rank > highestTrumpCard.Rank)
{
highestTrumpCard = card;
}
}
return highestTrumpCard;
}
var firstSuit = cards[0].Suit;
return cards.Where(a => a.Suit == firstSuit).Aggregate(
(curMin, x) =>
(x.Rank > curMin.Rank ? x : curMin));
}
/// <summary>
/// Deals the specified players.
/// </summary>
/// <param name="players">The players.</param>
/// <param name="cardsOnBoard">The cards on board.</param>
public void Deal(IList<IParticipant> players, ICard[] cardsOnBoard)
{
this.Shuffle();
int toTakeFromDeckIndex = 0;
// deal cards to players
foreach (IParticipant player in players.Where(p => p.IsInGame))
{
this.DealCardsToPlayers(player, ref toTakeFromDeckIndex);
}
// place cards on board
Point boardCardsPosition = GlobalVariables.BoardCardsPlace;
int positionCardChangeX = boardCardsPosition.X;
for (int i = 0; i < 5; i++)
{
this.DealCardsOnBoard(
cardsOnBoard,
i,
ref toTakeFromDeckIndex,
boardCardsPosition,
ref positionCardChangeX);
}
// turn the player cards up
foreach (var player in players.Where(p => p.IsInGame && p is Player))
{
player.Hand.CurrentCards[0].IsFacingUp = true;
player.Hand.CurrentCards[1].IsFacingUp = true;
}
}
IEnumerable<ModuleDefMD> SortGraph(IEnumerable<ModuleDefMD> roots, IList<DependencyGraphEdge> edges)
{
var visited = new HashSet<ModuleDefMD>();
var queue = new Queue<ModuleDefMD>(roots);
do {
while (queue.Count > 0) {
var node = queue.Dequeue();
visited.Add(node);
Debug.Assert(!edges.Where(edge => edge.To == node).Any());
yield return node;
foreach (DependencyGraphEdge edge in edges.Where(edge => edge.From == node).ToList()) {
edges.Remove(edge);
if (!edges.Any(e => e.To == edge.To))
queue.Enqueue(edge.To);
}
}
if (edges.Count > 0) {
foreach (var edge in edges) {
if (!visited.Contains(edge.From)) {
queue.Enqueue(edge.From);
break;
}
}
}
} while (edges.Count > 0);
}
public void UpdateInvoiceDetails(IList<InvoiceDetail> invoiceDetails, IList<int> deleteIds)
{
Process(() =>
{
if (invoiceDetails != null && invoiceDetails.Count > 0)
{
var ids = invoiceDetails.Select(x => x.Id);
var invoicesInDb = invoiceDetailRepository.Query().Where(x => ids.Contains(x.Id)).ToList();
var idsInDb = invoicesInDb.Select(x => x.Id);
foreach (var invoice in invoicesInDb)
{
var item = invoiceDetails.Where(x => x.Id == invoice.Id).First();
invoice.Description = item.Description;
invoice.Quantity = item.Quantity;
invoice.Price = item.Price;
}
var invoicesNotInDb = invoiceDetails.Where(x => !idsInDb.Contains(x.Id));
foreach (var invoice in invoicesNotInDb)
{
invoiceDetailRepository.Insert(invoice);
}
}
if (deleteIds != null && deleteIds.Count > 0)
{
DeleteInvoiceDetails(deleteIds);
}
this.unitOfWork.Commit();
});
}
public async Task<IssuesCollectionStatistics> Calculate(IList<JiraIssue> issues)
{
if(issues == null || issues.Any() == false)
return null;
return await Task.Factory.StartNew(() =>
{
return new IssuesCollectionStatistics
{
IssuesCount = issues.Count(),
ResolvedIssuesCount = issues.Where(i => i.Resolved.HasValue).Count(),
UnresolvedIssuesCount = issues.Where(i => i.Resolved.HasValue == false).Count(),
AverageResolutionTimeHours = issues
.Where(i => i.Resolved.HasValue)
.Select(i => (i.Resolved.Value - i.Created).TotalHours).Average(),
MaxResolutionTimeHours = issues
.Where(i => i.Resolved.HasValue)
.Select(i => (i.Resolved.Value - i.Created).TotalHours).Max(),
TotalStorypoints = issues.Sum(i => i.StoryPoints),
AverageStorypointsPerTask = issues.Average(i => i.StoryPoints),
AverageSubtasksCount = issues.Average(i => i.Subtasks),
EpicsInvolved = issues.Select(i => i.EpicLink).Distinct().Count(),
DistinctReporters = issues.Select(i => i.Reporter).Distinct().Count()
};
});
}
private string FormatDeletePatterns(IList<ITriple> deletePatterns, string updateGraphUri)
{
var deleteCmds = new StringBuilder();
int propId = 0;
if (deletePatterns.Any(p => IsGraphTargeted(p) && IsGrounded(p)))
{
deleteCmds.AppendLine("DELETE DATA {");
foreach (var patternGroup in deletePatterns.Where(p => IsGraphTargeted(p) && IsGrounded(p)).GroupBy(p=>p.Graph))
{
deleteCmds.AppendFormat("GRAPH <{0}> {{", patternGroup.Key);
deleteCmds.AppendLine();
foreach (var deletePattern in patternGroup)
{
AppendTriplePattern(deletePattern, deleteCmds);
}
deleteCmds.AppendLine("}");
}
deleteCmds.AppendLine("};");
}
foreach (var deletePattern in deletePatterns.Where(p=>IsGraphTargeted(p) && !IsGrounded(p)))
{
deleteCmds.AppendFormat("WITH <{0}> DELETE {{ {1} }} WHERE {{ {1} }};",
deletePattern.Graph, FormatDeletePattern(deletePattern, ref propId));
}
if (deletePatterns.Any(p => !IsGraphTargeted(p) && IsGrounded(p)))
{
// Delete from default graph
deleteCmds.AppendLine("DELETE DATA {");
foreach (var p in deletePatterns.Where(p => !IsGraphTargeted(p) && IsGrounded(p)))
{
AppendTriplePattern(p, deleteCmds);
}
// If an update graph is specified delete from that too
if (updateGraphUri != null)
{
deleteCmds.AppendFormat("GRAPH <{0}> {{", updateGraphUri);
deleteCmds.AppendLine();
foreach (var p in deletePatterns.Where(p => !IsGraphTargeted(p) && IsGrounded(p)))
{
AppendTriplePattern(p, deleteCmds);
}
deleteCmds.AppendLine("}");
}
deleteCmds.AppendLine("};");
}
foreach (var deletePattern in deletePatterns.Where(p => !IsGraphTargeted(p) && !IsGrounded(p)))
{
var cmd = String.Format("DELETE {{ {0} }} WHERE {{ {0} }};",
FormatDeletePattern(deletePattern, ref propId));
deleteCmds.AppendLine(cmd);
if (updateGraphUri != null)
{
deleteCmds.AppendFormat("WITH <{0}> ", updateGraphUri);
deleteCmds.AppendLine(cmd);
}
}
return deleteCmds.ToString();
}
public virtual void PrintReportFooter(StreamWriter streamWriter, IList<AllItem> allItems)
{
int drCount = allItems.Count(ai => ai.Classification == "Dr");
int crCount = allItems.Count(ai => ai.Classification == "Cr");
decimal drAmount = allItems.Where(ai => ai.Classification == "Dr").Sum(ai => ai.Amount);
decimal crAmount = allItems.Where(ai => ai.Classification == "Cr").Sum(ai => ai.Amount);
streamWriter.WriteLine(string.Format(this.reportFooterFormat, drCount, drAmount, crCount, crAmount));
}
private IEnumerable<FieldDeclarationSyntax> GetRuleViolations(IList<dynamic> fieldsInfo)
{
if (fieldsInfo.Any(f => !f.IsCollection))
{
return fieldsInfo.Where(f => f.IsCollection).Select(f => f.Syntax as FieldDeclarationSyntax);
}
if (fieldsInfo.Any(f => f.IsCollection))
{
return fieldsInfo.Where(f => f.IsCollection).Skip(1).Select(f => f.Syntax as FieldDeclarationSyntax);
}
return new List<FieldDeclarationSyntax>();
}
private static AmazonChartModel SetChartModel(DateTime from, DateTime to, IList<KeyValuePair<DateTime, decimal>> items)
{
var data = new Dictionary<string, decimal>();
var labels = new List<string>();
var ts = to - from;
var factor = (ts.Days/7)+1;
var oldDate = DateTime.Parse(from.Date.ToString());
var currentDate = oldDate;
for (var i = 0; i < 7; i++)
{
oldDate = currentDate;
currentDate = oldDate.AddDays(ts.Days <= 7 ? 1 : factor);
labels.Add(oldDate.ToString("dd/MM"));
data.Add(oldDate.ToString("dd/MM"), i == 0
? items.Where(x => x.Key.Date == currentDate.Date).Sum(x => x.Value)
: items.Where(x => oldDate.Date <= x.Key && x.Key <= currentDate.Date)
.Sum(x => x.Value));
}
return new AmazonChartModel
{
Labels = labels,
Data = data
};
}
public void AddButtons(IList<CustomMenu> menuList)
{
var rootMenus = menuList.Where(p => !p.ParentMenuID.HasValue).Select(p => new MenuButton
{
ID = p.ID,
Type = MenuTypeToString((EnumMenuType)p.Type),
Name = p.Name,
Key = p.Key,
Url = p.View_Url
}).ToList();
var childrenMenu = menuList.Where(p => p.ParentMenuID.HasValue).GroupBy(p => p.ParentMenuID);
foreach (var menuButton in rootMenus)
{
if (!childrenMenu.Any(p => p.Key == menuButton.ID))
{
continue;
}
var subMenus = childrenMenu.FirstOrDefault(p => p.Key == menuButton.ID);
menuButton.SubButton = subMenus.Select(p => new MenuButton
{
Type = MenuTypeToString((EnumMenuType)p.Type),
Name = p.Name,
Key = p.Key,
Url = p.View_Url
}).ToList();
menuButton.Key = string.Empty;
menuButton.Type = string.Empty;
menuButton.Url = string.Empty;
}
Button = rootMenus;
}
private static bool TryFindMatchingArgument(IList<string> args, string argumentKey, out string arg)
{
arg = null;
//if the key ends with a colon (:) that means it has an associated value, otherwise there should be no additional characters
//and the key is the entire argument
//
IEnumerable<string> matchingArgs;
if(argumentKey.EndsWith(":", StringComparison.OrdinalIgnoreCase) )
{
matchingArgs = args.Where(a => a.StartsWith(argumentKey, StringComparison.OrdinalIgnoreCase));
}
else
{
matchingArgs = args.Where(a => a.Equals(argumentKey, StringComparison.OrdinalIgnoreCase));
}
if (matchingArgs.Count() > 1)
{
throw new ApplicationException(string.Format("Multiple arguments of name {0} specified", argumentKey));
}
else if (matchingArgs.Count() == 1)
{
arg = matchingArgs.First();
return true;
}
return false;
}
public static int CalculateUnverifiedRank(this Competitor competitor , IList<Match> matches)
{
return (competitor.Rating +
matches.Where(x => x.Loser.ProfileUserId == competitor.ProfileUserId && !x.IsResolved)
.Sum(x => x.LoserRatingDelta) +
matches.Where(x => x.Winner.ProfileUserId == competitor.ProfileUserId && !x.IsResolved)
.Sum(x => x.WinnerRatingDelta));
}
private static void _writeResults( IList<Result> results )
{
Console.WriteLine( "************************************************************************" );
Console.WriteLine();
Console.WriteLine( "Singletons" );
Console.WriteLine( "==============================" );
Console.WriteLine( "Fastest registrations --------" );
results
.Where( r => r.Mode == "Singleton" )
.OrderBy( r => r.RegisterTime )
.ToList()
.ForEach(
r => Console.WriteLine( " {0," + ( Program.MaxContainerNameLength + 1 ) + "}: {1,11:##0.0000}ms", r.Name, r.RegisterTime )
);
Console.WriteLine();
Console.WriteLine( "Fastest resolvers ------------" );
results
.Where( r => r.Mode == "Singleton" )
.OrderBy( r => r.ResolveTime )
.ToList()
.ForEach(
r => Console.WriteLine( " {0," + ( Program.MaxContainerNameLength + 1 ) + "}: {1,11:##0.0000}ms", r.Name, r.ResolveTime )
);
Console.WriteLine();
Console.WriteLine();
Console.WriteLine( "Transients" );
Console.WriteLine( "==============================" );
Console.WriteLine( "Fastest registrations --------" );
results
.Where( r => r.Mode == "Transient" )
.OrderBy( r => r.RegisterTime )
.ToList()
.ForEach(
r => Console.WriteLine( " {0," + ( Program.MaxContainerNameLength + 1 ) + "}: {1,11:##0.0000}ms", r.Name, r.RegisterTime )
);
Console.WriteLine();
Console.WriteLine( "Fastest resolvers ------------" );
results
.Where( r => r.Mode == "Transient" )
.OrderBy( r => r.ResolveTime )
.ToList()
.ForEach(
r => Console.WriteLine( " {0," + ( Program.MaxContainerNameLength + 1 ) + "}: {1,11:##0.0000}ms", r.Name, r.ResolveTime )
);
Console.WriteLine();
Console.WriteLine();
}
public QuestionListPage(IList<Question> questionList, string filter, AppEnums.QuestionListFilter filterType )
{
InitializeComponent();
switch (filterType)
{
case AppEnums.QuestionListFilter.UnAnswered:
{
QuestionList = questionList.Where(x => x.Unanswered).ToList();
StudyPlan = filter;
this.BindingContext = AppCache.AssignNumberToQuestion(QuestionList, SessionType.PractiseMode);
break;
}
case AppEnums.QuestionListFilter.AnsweredCorrectly:
{
QuestionList =
questionList.Where(x => x.AnsweredCorrectly != null && x.AnsweredCorrectly.Value).ToList();
StudyPlan = filter;
this.BindingContext = AppCache.AssignNumberToQuestion(QuestionList, SessionType.PractiseMode);
break;
}
case AppEnums.QuestionListFilter.AnsweredIncorrectly:
{
QuestionList =
questionList.Where(x => x.AnsweredCorrectly != null && x.AnsweredCorrectly.Value.Equals(false)).ToList();
StudyPlan = filter;
this.BindingContext = AppCache.AssignNumberToQuestion(QuestionList, SessionType.PractiseMode);
break;
}
case AppEnums.QuestionListFilter.StudyPlan:
{
QuestionList = questionList.Where(x => x.StudyPlan.Equals(filter)).ToList();
StudyPlan = filter;
this.BindingContext = AppCache.AssignNumberToQuestion(QuestionList, SessionType.PractiseMode);
break;
}
case AppEnums.QuestionListFilter.Favorite:
{
QuestionList = questionList.Where(x => x.IsFavorite != null && x.IsFavorite.Value).ToList();
StudyPlan = filter;
this.BindingContext = AppCache.AssignNumberToQuestion(QuestionList, SessionType.PractiseMode);
break;
}
default:
this.BindingContext = AppCache.AssignNumberToQuestion(QuestionList, SessionType.PractiseMode);
break;
}
}
/// <summary>
/// Initializes a new instance of <see cref="HookableSagaStore"/> with <paramref name="pipelineHooks"/> safe to enumerate multiple times.
/// </summary>
/// <param name="sagaStore">The underlying <see cref="IStoreSagas"/> implementation to be decorated.</param>
/// <param name="pipelineHooks">The set of zero or more <see cref="PipelineHook"/> implementations used to extend <see cref="IStoreSagas"/> behavior.</param>
private HookableSagaStore(IStoreSagas sagaStore, IList<PipelineHook> pipelineHooks)
{
Verify.NotNull(sagaStore, nameof(sagaStore));
this.sagaStore = sagaStore;
this.preGetHooks = pipelineHooks.Where(pipelineHook => pipelineHook.ImplementsPreGet).ToArray();
this.postGetHooks = pipelineHooks.Where(pipelineHook => pipelineHook.ImplementsPostGet).Reverse().ToArray();
this.preSaveHooks = pipelineHooks.Where(pipelineHook => pipelineHook.ImplementsPreSave).ToArray();
this.postSaveHooks = pipelineHooks.Where(pipelineHook => pipelineHook.ImplementsPostSave).Reverse().ToArray();
}
protected virtual IEnumerable<SiteMapNode> GroupNodes(IList<SiteMapNode> nodes)
{
//get root nodes
var rootNodes = nodes.Where(x => x.IsRootNode).ToList();
//populate child nodes for each root node
foreach (var node in rootNodes) {
var children = nodes.Where(x => x.ParentId == node.Id).ToList();
node.Children = children;
}
return rootNodes;
}
public ResultsViewModel(string query, IList<Match> matches, double elapsedMilliseconds, int nodes)
{
if (matches == null) throw new ArgumentNullException("matches");
Query = query;
Words = matches.Where(m => m.Type == MatchType.Word).Select(m => m.Value).ToList();
Anagrams = matches.Where(m => m.Type == MatchType.Anagram).Select(m => m.Value).ToList();
Near = matches.Where(m => m.Type == MatchType.Near).Select(m => m.Value).ToList();
ElapsedMilliseconds = elapsedMilliseconds;
Nodes = nodes;
}
private void ObtenerRematesAdicionales(ref IList<co_re_remates> listRemates, co_re_remates remate)
{
if (remate.id_familia == Constantes.FAMILIA_BIENESMUEBLES || remate.id_familia == Constantes.FAMILIA_BIENESMUEBLES_VENTADIRECTA)
{
listRemates = listRemates.Where(c => c.id_familia == Constantes.FAMILIA_BIENESMUEBLES || c.id_familia == Constantes.FAMILIA_BIENESMUEBLES_VENTADIRECTA).ToList();
}
else if (remate.id_familia == Constantes.FAMILIA_PROPIEDADES || remate.id_familia == Constantes.FAMILIA_PROPIEDADES_VENTADIRECTA)
{
listRemates = listRemates.Where(c => c.id_familia == Constantes.FAMILIA_PROPIEDADES || c.id_familia == Constantes.FAMILIA_PROPIEDADES_VENTADIRECTA).ToList();
}
}
public static Statistics GetStatistics(IList<PlayTime> playTimes, IList<Program> programs, TimePeriod timePeriod)
{
var helper = new DateTimeHelper();
List<PlayTime> times;
switch (timePeriod)
{
case TimePeriod.Day:
times = playTimes.Where(x => helper.IsToday(x.Timestamp)).ToList();
break;
case TimePeriod.Week:
times = playTimes.Where(x => helper.IsCurrentWeek(x.Timestamp)).ToList();
break;
case TimePeriod.Month:
times = playTimes.Where(x => helper.IsCurrentMonth(x.Timestamp)).ToList();
break;
case TimePeriod.Year:
times = playTimes.Where(x => helper.IsCurrentYear(x.Timestamp)).ToList();
break;
case TimePeriod.Ever:
times = playTimes.ToList();
break;
default:
throw new ArgumentOutOfRangeException(nameof(timePeriod), timePeriod, null);
}
var statistic = new Statistics
{
TimePeriod = timePeriod,
TimePlayed = TimeSpan.FromMilliseconds(times.Select(x => x.Duration.TotalMilliseconds).Sum())
};
var games = new List<GameStatistic>();
foreach (var gameId in times.Select(x => x.Program).Distinct())
{
var game = programs.FirstOrDefault(x => x.Guid == gameId);
if (game == null)
continue;
games.Add(new GameStatistic
{
Name = game.Name,
Icon = game.Icon,
Guid = game.Guid,
ChartColor = GetColor(game),
TimePlayed =
TimeSpan.FromMilliseconds(
times.Where(x => x.Program == game.Guid).Select(x => x.Duration.TotalMilliseconds).Sum())
});
}
statistic.Games = games.OrderByDescending(x => x.TimePlayed).ToList();
return statistic;
}
public DiagnosticsListMessage(IList<DiagnosticMessageView> diagnostics, FrameworkData frameworkData)
{
if (diagnostics == null)
{
throw new ArgumentNullException(nameof(diagnostics));
}
Diagnostics = diagnostics;
Errors = diagnostics.Where(msg => msg.Severity == DiagnosticMessageSeverity.Error).ToList();
Warnings = diagnostics.Where(msg => msg.Severity == DiagnosticMessageSeverity.Warning).ToList();
Framework = frameworkData;
}
public static void RegisterDisplayModes(IList<IDisplayMode> displayModes)
{
// The default mode
var defaultMode = displayModes.Where(c => c.DisplayModeId == "").FirstOrDefault();
// The mobile view
var mobileMode = displayModes.Where(c => c.DisplayModeId == "Mobile").FirstOrDefault();
displayModes.Clear();
displayModes.Add(mobileMode);
displayModes.Add(defaultMode);
}
public Span TokensToSpan(IList<Token> tokens, Options options)
{
var handlersToMatch = _registry
.GetHandlers(HandlerType.Endian)
.Concat(_registry.GetHandlers(HandlerType.Date));
foreach (var handler in handlersToMatch)
{
if (handler.Match(tokens, _registry))
{
var targetTokens = tokens
.Where(x => x.IsNotTaggedAs<Separator>())
.ToList();
return ExecuteHandler(handler, targetTokens, options);
}
}
foreach (var handler in _registry.GetHandlers(HandlerType.Anchor))
{
if (handler.Match(tokens, _registry))
{
var targetTokens = tokens
.Where(x => x.IsNotTaggedAs<Separator>())
.ToList();
return ExecuteHandler(handler, targetTokens, options);
}
}
foreach (var handler in _registry.GetHandlers(HandlerType.Arrow))
{
if (handler.Match(tokens, _registry))
{
var targetTokens = tokens
.Where(x =>
x.IsNotTaggedAs<SeparatorAt>() &&
x.IsNotTaggedAs<SeparatorComma>() &&
x.IsNotTaggedAs<SeparatorDate>())
.ToList();
return ExecuteHandler(handler, targetTokens, options);
}
}
foreach (var handler in _registry.GetHandlers(HandlerType.Narrow))
{
if (handler.Match(tokens, _registry))
{
return ExecuteHandler(handler, tokens, options);
}
}
return null;
}
private IList<Resource> GetResourceTree(IList<Resource> list,Guid fcode)
{
var ss=list.Where(r=>r.F_ResourceID.Equals(fcode));
foreach(Resource re in ss)
{
if(list.Count(r=>r.F_ResourceID.Equals(re.ResourceID))>0)
{
re.children=GetResourceTree(list.Where(r=>r.F_ResourceID.Equals(re.ResourceID)).ToList()
,re.ResourceID);
}
}
return ss.ToList();
}
public void Update(IList<ICreature> creatures, IList<Tuple<ObjectType, IList<double>>> objects, MineSweeperSettings settings)
{
Image = new Bitmap(Width, Height);
using (var graphics = Graphics.FromImage(Image))
{
var eliteSweeperPen = new Pen(_bestColor);
var sweeperPen = new Pen(_neutralColor);
var minePen = new Pen(Color.DarkGray);
var blackPen = new Pen(Color.Black);
var redPen = new Pen(Color.Maroon);
// Elite Sweepers
foreach (var sweeper in creatures.OrderByDescending(x => x.Fitness).Take(settings.EliteCount))
{
drawSweeper(graphics, eliteSweeperPen, eliteSweeperPen.Brush, sweeper, settings.SweeperSize);
}
// Normal Sweepers
foreach (var sweeper in creatures.OrderByDescending(x => x.Fitness).Skip(settings.EliteCount))
{
drawSweeper(graphics, sweeperPen, sweeperPen.Brush, sweeper, settings.SweeperSize);
}
// Mines
var mines = objects.Where(x => x.Item1 == ObjectType.Mine).Select(x => x.Item2);
foreach (var mine in mines)
{
drawMine(graphics, redPen, minePen.Brush, mine, settings.MineSize);
}
// ClusterMines
var clusterMines = objects.Where(x => x.Item1 == ObjectType.ClusterMine).Select(x => x.Item2);
foreach (var mine in clusterMines)
{
drawMine(graphics, blackPen, sweeperPen.Brush, mine, settings.MineSize + 1);
}
// Holes
var holes = objects.Where(x => x.Item1 == ObjectType.Hole).Select(x => x.Item2);
foreach (var hole in holes)
{
drawMine(graphics, redPen, redPen.Brush, hole, settings.MineSize + 1);
}
eliteSweeperPen.Dispose();
sweeperPen.Dispose();
minePen.Dispose();
blackPen.Dispose();
redPen.Dispose();
}
}
public IList<Resource> BuidTree(IList<Resource> list, string ReFcode)
{
var ss = list.Where(r => r.F_ResourceID.Equals(Guid.Parse(ReFcode)));
foreach (Resource resource in ss)
{
if (list.Count(r => r.F_ResourceID.Equals(resource.ResourceID)) > 0)
{
resource.children = new List<Resource>();
resource.children = BuidTree(list.Where(r => r.F_ResourceID.Equals(resource.ResourceID)).ToList(),
resource.ResourceID.ToString());
}
}
return ss.ToList();
}
public TestAssembly(string assemblyName, IList<IFilter> filters)
{
Name = assemblyName;
_filters = filters;
_testAssembly = Assembly.UnsafeLoadFrom(assemblyName);
Classes = (
from type in _testAssembly.GetTypes()
where type.GetCustomAttributes(typeof(TestClassAttribute), true).Any()
where !type.IsAbstract
select new TestClass(type, _filters)).ToList();
_initializeClasses = Classes.Where(testClass => testClass.HasAssemblyInitialize).ToList();
_cleanupClasses = Classes.Where(testClass => testClass.HasAssemblyCleanup).ToList();
}
/// <summary>
/// Converts the specified input classes into the output classes.
/// </summary>
/// <param name="inputClasses">The input classes.</param>
/// <returns>The output classes</returns>
public static IEnumerable<OutputClass> Convert(IList<InputClass> inputClasses)
{
var axList = inputClasses.Where(x => x.Ax == true).ToList();
var ayList = inputClasses.Where(x => x.Ay == true).ToList();
var bxList = inputClasses.Where(x => x.Bx == true).ToList();
var byList = inputClasses.Where(x => x.By == true).ToList();
var groupA = Join(axList, ayList, "A");
var groupB = Join(bxList, byList, "B");
var outputList = groupA.Concat(groupB);
return outputList;
}
