public IEnumerable<ValidationError> Validate(IList<Benchmark> benchmarks)
{
#if CORE
yield break; // todo: implement when it becomes possible
#else
foreach (var group in benchmarks.GroupBy(benchmark => benchmark.Target.Type.Assembly()))
{
foreach (var referencedAssemblyName in group.Key.GetReferencedAssemblies())
{
var referencedAssembly = Assembly.Load(referencedAssemblyName);
if (IsJITOptimizationDisabled(referencedAssembly))
{
yield return new ValidationError(
TreatsWarningsAsErrors,
$"Assembly {group.Key} which defines benchmarks references non-optimized {referencedAssemblyName.Name}");
}
}
if (IsJITOptimizationDisabled(group.Key))
{
yield return new ValidationError(
TreatsWarningsAsErrors,
$"Assembly {group.Key} which defines benchmarks is non-optimized");
}
}
#endif
}
protected internal IEnumerable<IGrouping<CardFigure, Card>> GetSets(IList<Card> cards, int cardsInSet)
{
// broke my original linq up so it can be debugged. This is a good idea? or bad idea? Then put it back together
return cards
.GroupBy<Card, CardFigure>(key => key.Figure)
.Where<IGrouping<CardFigure, Card>>(group => group.Count<Card>() == cardsInSet);
}
private void GenerateDateRangeCollection()
{
_dayForecastCollection = new List<DayForecast>();
_startDateDaysInMonth = DateTime.DaysInMonth(_startDate.Year, _startDate.Month);
_endDateDaysInMonth = DateTime.DaysInMonth(_endDate.Year, _endDate.Month);
_monthDifference = Microsoft.VisualBasic.DateAndTime.DateDiff(Microsoft.VisualBasic.DateInterval.Month, _startDate, _endDate);
ProcessDayForecastCollection(_startDateDaysInMonth, _startDate, _dayForecastCollection);
for (int i = 1; i < _monthDifference; i++)
{
DateTime inbetweenDt = _startDate.AddMonths(i);
var inbetweenDtDaysInMonth = DateTime.DaysInMonth(inbetweenDt.Year, inbetweenDt.Month);
ProcessDayForecastCollection(inbetweenDtDaysInMonth, inbetweenDt, _dayForecastCollection);
}
List<DayForecast> weekItem = new List<DayForecast>();
_weekDayForecastCollection = new List<List<DayForecast>>();
foreach(var df in _dayForecastCollection)
{
weekItem.Add(df);
if (df.FullDayOfTheWeek == _dayForecastConfiguration.DayEndOfWeek)
{
_weekDayForecastCollection.Add(weekItem);
weekItem = new List<DayForecast>();
}
}
_week = _dayForecastCollection.GroupBy(d => d.FullDayOfTheWeek).Select(gd => gd.Key).ToList();
//here
}
public DesignTimeCompilationException(IList<DiagnosticMessage> compileResponseErrors)
: base(string.Join(Environment.NewLine, compileResponseErrors.Select(e => e.FormattedMessage)))
{
CompilationFailures = compileResponseErrors.GroupBy(g => g.SourceFilePath, StringComparer.OrdinalIgnoreCase)
.Select(g => new CompilationFailure(g.Key, g))
.ToArray();
}
public MainWindow()
{
InitializeComponent();
Loaded += (sender, e) => ClearValue(SizeToContentProperty);
_allControllerViewModels =
(from type in GetType().Assembly.GetTypes()
where !type.IsInterface && typeof(IController).IsAssignableFrom(type)
let viewModel = new ControllerViewModel((IController)Activator.CreateInstance(type))
orderby viewModel.SortIndex, viewModel.Library, viewModel.Description
select viewModel).ToList();
_allControllerViewModels.First().IsChecked = true;
ControllerGroups.ItemsSource = _allControllerViewModels.GroupBy(viewModel => viewModel.Library);
_allResolutionViewModels = new[] {
new ResolutionViewModel(800, 600, 50, 42),
new ResolutionViewModel(1024, 768, 64, 54),
new ResolutionViewModel(1280, 1024, 80, 73),
new ResolutionViewModel(1440, 900, 90, 64),
};
_allResolutionViewModels.Last(
res => res.Width <= SystemParameters.PrimaryScreenWidth &&
res.Height <= SystemParameters.PrimaryScreenHeight).IsChecked = true;
Resolutions.ItemsSource = _allResolutionViewModels;
RunResults.ItemsSource = _runResults;
}
public IList<AcceptedUserComment> AddComments(string type, string clientToken, IList<UserComment> userComments)
{
if (userComments == null || userComments.Count == 0)
return null;
var acceptedComments = new List<AcceptedUserComment>();
var commentsForEvents = userComments.GroupBy(x=>x.eventId);
foreach (var eventGroup in commentsForEvents)
{
var userInfo = GetUserEventInfo(eventGroup.Key);
var dddEvent = eventsService.GetServerEventData(eventGroup.Key);
var eventDetail = eventsService.GetEventDetail(dddEvent);
if (dddEvent.IsActive)
{
var accepted = addComments(type, eventGroup.Key, eventDetail, userInfo != null ? userInfo.UserName : "", userInfo != null ? userInfo.UserToken : null, clientToken, eventGroup.ToList());
acceptedComments.AddRange(accepted);
}
else
{
//We don't want the client to keep sending the same message, so respond that it is accepted (even though it's not)
var accepted = eventGroup.Select(x => new AcceptedUserComment
{
eventId = x.eventId,
id = x.id,
sessionId = x.sessionId
});
return accepted.ToList();
}
}
return acceptedComments;
}
public void SetUp()
{
_listaGruppi = new List<SferaAziendeDTO>
{
new SferaAziendeDTO {Codice = "AZI01", Gruppo = "GR1", Id = 1},
new SferaAziendeDTO {Codice = "AZI02", Gruppo = "GR1", Id = 2},
new SferaAziendeDTO {Codice = "AZI03", Gruppo = "GR2", Id = 3},
new SferaAziendeDTO {Codice = "AZI04", Gruppo = "GR2", Id = 4},
new SferaAziendeDTO {Codice = "AZI05", Gruppo = "GR3", Id = 5},
new SferaAziendeDTO {Codice = "AZI06", Gruppo = "GR3", Id = 6},
new SferaAziendeDTO {Codice = "AZI07", Gruppo = "GR4", Id = 7},
new SferaAziendeDTO {Codice = "AZI08", Gruppo = "GR4", Id = 8}
};
_aziendaService = MockRepository.GenerateStub<IAziendaService>();
_aziendaService.Stub(x => x.GetAllGruppi()).Return(_listaGruppi.GroupBy(item => item.Gruppo).ToList());
_richiestaImportazioneDocumentiBolletteService = MockRepository.GenerateMock<IRichiestaImportazioneDocumentiBolletteService>();
_importazioneDocumentiBolletteService = MockRepository.GenerateMock<IImportazioneDocumentiBolletteService>();
_windsorContainer = MockRepository.GenerateStub<IWindsorContainer>();
_windsorContainer.Stub(x => x.Resolve<IRichiestaImportazioneDocumentiBolletteService>()).Return(_richiestaImportazioneDocumentiBolletteService);
_windsorContainer.Stub(x => x.Resolve<IImportazioneDocumentiBolletteService>()).Return(_importazioneDocumentiBolletteService);
_iocContainerService = MockRepository.GenerateStub<IIocContainerService>();
_iocContainerService.Stub(x => x.GetContainerFromKey(Arg<string>.Is.Anything)).Return(_windsorContainer);
_utenzaRicezioneDocumentoJob = new UtenzaRicezioneDocumentoJob(_aziendaService, _iocContainerService);
}
private void OnReferenceLocationsChanged(object sender, IList<InlineRenameLocation> renameLocations)
{
int totalFilesCount = renameLocations.GroupBy(s => s.Document).Count();
int totalSpansCount = renameLocations.Count;
UpdateSearchText(totalSpansCount, totalFilesCount);
}
public static int GetPowerScores(IList<string> powerPhrases)
{
return powerPhrases
.GroupBy(e => e)
.Select(e => new {PowerPhrase = e.Key, Amount = e.Count()})
.Aggregate(0, (sum, info) => sum + GetPowerScore(info.PowerPhrase, info.Amount));
}
public IEnumerable<ValidationError> Validate(IList<Benchmark> benchmarks)
{
var errors = new List<ValidationError>();
foreach (var typeGroup in benchmarks.GroupBy(benchmark => benchmark.Target.Type))
{
object benchmarkTypeInstance = null;
if (!TryCreateBenchmarkTypeInstance(typeGroup.Key, typeGroup, errors, out benchmarkTypeInstance))
{
continue;
}
if (!TryToSetParamsFields(benchmarkTypeInstance, typeGroup, errors))
{
continue;
}
if (!TryToSetParamsProperties(benchmarkTypeInstance, typeGroup, errors))
{
continue;
}
if (!TryToCallSetup(benchmarkTypeInstance, typeGroup, errors))
{
continue;
}
ExecuteBenchmarks(benchmarkTypeInstance, typeGroup, errors);
}
return errors;
}
IList<ReceiptItem> MergeReceiptItems(IList<BoughtProduct> boughtProducts)
{
string[] barcodes = boughtProducts.Select(bp => bp.Barcode).Distinct().ToArray();
Dictionary<string, Product> boughtProductSet = m_productRepository
.GetByBarcodes(barcodes)
.ToDictionary(p => p.Barcode, p => p);
Dictionary<string,int> boughtDictionary = boughtProducts.GroupBy(bp => bp.Barcode)
.ToDictionary(g => g.Key, g => g.Sum(bp => bp.Amount));
var buyTwoGetOne = new BuyTwoGetOne(m_promotionRepository, m_productRepository);
Dictionary<string, decimal> boughtProductPromoted = buyTwoGetOne.GetPromoted(boughtDictionary);
return boughtProducts
.GroupBy(bp => bp.Barcode)
.Select(g => new ReceiptItem(boughtProductSet[g.Key], g.Sum(bp => bp.Amount),boughtProductPromoted[g.Key]))
.ToArray();
}
/// <summary>
/// Sort the items by their priority and their index they currently exist in the collection
/// </summary>
/// <param name="files"></param>
/// <returns></returns>
public static IList<IClientDependencyFile> SortItems(IList<IClientDependencyFile> files)
{
//first check if each item's order is the same, if this is the case we'll make sure that we order them
//by the way they were defined
if (!files.Any()) return files;
var firstPriority = files.First().Priority;
if (files.Any(x => x.Priority != firstPriority))
{
var sortedOutput = new List<IClientDependencyFile>();
//ok they are not the same so we'll need to sort them by priority and by how they've been entered
var groups = files.GroupBy(x => x.Priority).OrderBy(x => x.Key);
foreach (var currentPriority in groups)
{
//for this priority group, we'll need to prioritize them by how they are found in the files array
sortedOutput.AddRange(currentPriority.OrderBy(files.IndexOf));
}
return sortedOutput;
}
//they are all the same so we can really just return the original list since it will already be in the
//order that they were added.
return files;
}
public DashboardViewModel(IEnumerable<WebSite> websites, IList<SyncStatus> syncStatuses)
{
Instances = syncStatuses.GroupBy(s => s.RoleInstanceId)
.Select(s => new InstanceViewModel {Name = s.Key, IsOnline = s.First().IsOnline})
.ToList();
Sites = websites.Select(w => new SiteViewModel
{
Id = w.Id,
Name = w.Name,
SyncStatus = Instances.ToDictionary(
i => i.Name,
i => syncStatuses
.Where(s => s.SiteName.Equals(w.Name, StringComparison.InvariantCultureIgnoreCase)
&& s.RoleInstanceId.Equals(i.Name, StringComparison.InvariantCultureIgnoreCase)
)
.Select(s =>
new SiteSyncViewModel
{
SyncError = s.LastError != null ? s.LastError.Message : null,
SyncStatus = s.Status.ToString(),
SyncTime = s.SyncTimestamp
}
)
.FirstOrDefault() ?? new SiteSyncViewModel{SyncStatus = "NotDeployed"}
)
});
}
//Get aggregates i.e WinPercentage and AverageBet for each customer in provided list of bets
public IList<Customer> GetCustomersStatistics(IList<Bet> settledBets)
{
var customers = new List<Customer>();
customers = settledBets.GroupBy(b => b.CustomerCode)
.Select(group => new Customer(group.Key, (group.Count(g => g.Win > 0) * 100) / group.Count(), Math.Round(group.Average(g => g.Stake), 2))).ToList();
return customers.OrderByDescending(o=>o.WinPercentage).ToList();
}
public SearchRootNode(string title, IList<SearchResultMatch> results)
{
this.Title = title;
this.results = results.Select(r => new SearchResultNode(r)).ToArray();
fileCount = results.GroupBy(r => r.FileName).Count();
this.Children = this.results;
this.IsExpanded = true;
}
public static int? FindMajorant(IList<int> numbers)
{
int minimumOccurencesRequired = (numbers.Count / 2) + 1;
return numbers
.GroupBy(x => x)
.Where(g => g.Count() >= minimumOccurencesRequired)
.Select(g => (int?)g.Key)
.SingleOrDefault();
}
private void CategoryFiller(IList<Project> projects, Func<Project, string> projectPropertySelector, IList<CategoryValue> list)
{
var summary = projects.GroupBy(projectPropertySelector).Select(g => new { Key = g.Key, Count = g.Count() });
var total = summary.Sum(t => t.Count);
foreach (var t in summary)
{
list.Add(new CategoryValue() { Value = t.Key, Count = t.Count, Ratio = (decimal)t.Count / (decimal)total });
}
}
IList<ReceiptItem> MergeReceiptItems(IList<BoughtProduct> boughtProducts)
{
string[] barcodes = boughtProducts.Select(bp => bp.Barcode).Distinct().ToArray();
Dictionary<string, Product> boughtProductSet = m_repository
.GetByBarcodes(barcodes)
.ToDictionary(p => p.Barcode, p => p);
return boughtProducts
.GroupBy(bp => bp.Barcode)
.Select(g => new ReceiptItem(boughtProductSet[g.Key], g.Sum(bp => bp.Amount)))
.ToArray();
}
/// <summary>
/// Mapping list of timeslot models into list of date models
/// </summary>
/// <param name="timeSlots">List of timeslot models</param>
/// <returns>List of date models</returns>
public static IList<EventModel.DatesModel> MapToDatesModel(IList<TimeSlot> timeSlots)
{
return timeSlots.GroupBy(ts => ts.DateTime.Date, ts => ts)
.Select(
tsGrp =>
new EventModel.DatesModel()
{
Date = tsGrp.Key.Date,
Times = tsGrp.Select(ts => new EventModel.TimeModel(ts.Id, ts.DateTime.ToString("HH:mm:ss"))).ToList()
}).ToList();
}
internal override IList<GuoKuItem> GetSpecialItems(IList<CaiWuItem> caiWus, IList<GuoKuItem> guoKus)
{
//按凭证号与总金额分组
var caiWuGroup = caiWus.GroupBy(c => c.GetNumber()).Select(g => new NumberGroupItem { Number = g.Key, Total = g.Sum(i => i.CreditAmount) }).ToList();
var guoKuGroup = guoKus.GroupBy(c => c.GetNumber()).Select(g => new NumberGroupItem { Number = g.Key, Total = g.Sum(i => i.Amount) }).ToList();
//比较凭证号与总金额
var numberAndAmountAreEqual = caiWuGroup.Intersect(guoKuGroup, new NumberGroupItemEqualityComparer()).ToList();
//根据凭证号与总金额比较结果，取出记录
var result = guoKus.Where(c => numberAndAmountAreEqual.Select(n => n.Number).Contains(c.GetNumber())).ToList();
return result;
}
private void CheckForDuplicates(IList<Category> newCategories)
{
var duplicateCategories = newCategories
.GroupBy(x => x.Name)
.Where(x => x.Count() > 1)
.Select(x => x.Key).ToArray();
if (duplicateCategories.Length > 0)
throw new DuplicateCategoryException(duplicateCategories);
}
static public PackageEntity BuildPackageXML(IList<IDeployableItem> items)
{
var response = items.GroupBy(g => g.Type)
.Select(s => new PackageTypeEntity
{
Name = s.Key.ToString(),
Members = s.Select(sm => sm.FileNameWithoutExtension).ToArray()
})
.ToArray();
return new PackageEntity { Version = "29.0", Types = response };
}
private static void ValidatePlayerRanks(IList<PlayerRank> playerRanks)
{
if (playerRanks.Count > FIBONACCI_N_PLUS_2.Count)
{
throw new ArgumentException(EXCEPTION_MESSAGE_CANNOT_EXCEED_MAX_PLAYERS);
}
if (playerRanks.GroupBy(x => x.PlayerId).Count(y => y.Count() > 1) > 0)
{
throw new ArgumentException(string.Format(EXCEPTION_MESSAGE_DUPLICATE_PLAYER));
}
}
private List<EnrichedData> GetDataWithCleanedDistance(IList<EnrichedData> input)
{
var byIds = input.GroupBy(rd => rd.DeviceIdentifier);
var values = byIds.Select(
gr =>
{
var id = gr.Key;
var distance = Median(gr.Select(ed => ed.Distance));
return new EnrichedData(id, distance);
}).ToList();
Log.Debug(beaconScanning, $"Found {values.Count} devices");
return values;
}
public static IEnumerable<string> GetResourcesForCulture(string cultureName, IList<string> resources)
{
var resourcesByCultureName = resources
.GroupBy(GetResourceCultureName, StringComparer.OrdinalIgnoreCase);
if (string.Equals(cultureName, "neutral", StringComparison.OrdinalIgnoreCase))
{
cultureName = string.Empty;
}
return resourcesByCultureName
.SingleOrDefault(grouping => string.Equals(grouping.Key, cultureName, StringComparison.OrdinalIgnoreCase));
}
/// <summary>
/// 取国库数据
/// 金额与记录数与财务相等
/// </summary>
/// <returns></returns>
internal override IList<GuoKuItem> GetSpecialItems(IList<CaiWuItem> caiWus, IList<GuoKuItem> guoKus)
{
//按金额与记录数分组
var caiWuGroup = caiWus.GroupBy(c => c.CreditAmount).Select(g => new AmountGroupItem { Amount = g.Key, Count = g.Count() }).ToList();
var guoKuGroup = guoKus.GroupBy(c => c.Amount).Select(g => new AmountGroupItem { Amount = g.Key, Count = g.Count() }).ToList();
//交集,取金额与记录数相等的数据项
var amountAndCountAreEqual = caiWuGroup.Intersect(guoKuGroup, new AmountCountEqualityComparer()).ToList();
//取国库对应数据
var result = guoKus.Where(c => amountAndCountAreEqual.Select(a => a.Amount).Contains(c.Amount)).ToList();
//返回
return result;
}
public IList <IGrouping <string, Base64Image> > GetDuplicateImageGroups(IList <Base64Image> images)
{
var groupedImages = images
?.GroupBy(i => i.Base64)
?.ToList() ?? new List <IGrouping <string, Base64Image> >();
Console.WriteLine($"Found {groupedImages.Count()} groups of images.");
var duplicateImageGroups = groupedImages.Where(grp => grp.Count() > 1);
Console.WriteLine($"Found {duplicateImageGroups.Count()} images with 2 or more copies");
return(duplicateImageGroups?.ToList() ?? new List <IGrouping <string, Base64Image> >());
}
private WeekSchedule ToWeekSchedule(IList <Exercise> exercises)
=> new WeekSchedule
{
ScheduleByDay = exercises
?.GroupBy(e => e.DayOfWeek)
.ToDictionary(
gd => (DayOfWeek)gd.Key,
gd => new DaySchedule
{
ExerciseByLessonNumber = gd.GroupBy(e => e.ExerciseNumber)
.ToDictionary(gn => gn.Key, gn => gn.ToList())
}
)
};
public IList<InventoryItemBase> Sort(IList<InventoryItemBase> items)
{
// Group them by ID, this will exceed stack limit.
var test = items.GroupBy(o => o.ID).
Select(o => new { item = o.First(), newStackSize = o.Sum(i => i.currentStackSize) }). // Get the items so we can re-assemble the items.
ToList();
// Move the items to a manageable array, still exceeding stack limits.
var sortedList = new List<InventoryItemBase>(test.Count);
for (int i = 0; i < test.Count; i++)
{
//sortedList.Add(test[i].item);
var item = test[i].item;
item.currentStackSize = (uint)test[i].newStackSize;
// Keep going until the stack is divided into parts of maxStackSizes
uint currentStackSize = item.currentStackSize;
while (currentStackSize > item.maxStackSize)
{
//// The old item becomes the max stack size, the remainder is pushed to the next index,
//// in the next loop, maxStackSize will be removed of that, and on and on until the stack is no longer to large.
var a = GameObject.Instantiate<InventoryItemBase>(item); // Copy the item
a.currentStackSize = item.maxStackSize;
sortedList.Add(a);
currentStackSize -= item.maxStackSize;
}
if(currentStackSize > 0)
{
// Got 1 pile left
var a = GameObject.Instantiate<InventoryItemBase>(item); // Copy the item
a.currentStackSize = currentStackSize;
sortedList.Add(a);
}
}
// Because the sorter creates copies we can remove the old
test.ForEach(o => Object.Destroy(o.item.gameObject));
// Orders by category.ID but can easilly be switched to anything else.
// Simply change o => o.category.ID to any object variable to sort by.
// For example: o => o.buyPrice will sort items based on the buying price.
// Another examlpe: o => o.name will sort items on an alphabetical order.
// If you want to go wild you can chain OrderBy's this allows you to filter on the first category first (for example category), then rarity. (check uncommented line below)
return sortedList.OrderBy(o => o.GetType().Name).ThenBy(o => o.category.ID).ThenBy(o => o.name).ToArray(); // Order by and return
//return sortedList.OrderBy(o => o.category.ID).ThenBy(o => o.rarity.ID).ToArray(); // Order by and return
}
public IEnumerable<ValidationError> Validate(IList<Benchmark> benchmarks)
{
foreach (var groupByType in benchmarks.GroupBy(benchmark => benchmark.Target.Type))
{
var allMethods = groupByType.Key.GetAllMethods();
var count = allMethods.Count(method => method.GetCustomAttributes<BenchmarkAttribute>(false)
.Any(benchmarkAttribute => benchmarkAttribute.Baseline));
if (count > 1)
{
yield return new ValidationError(
TreatsWarningsAsErrors,
$"Only 1 [Benchmark] in a class can have \"Baseline = true\" applied to it, class {groupByType.Key.Name} has {count}");
}
}
}
public static string UpdatePattern(IList<ChatUserMention> mentions)
{
_customCachedPattern = string.Format(CustomMentionPattern, String.Join("|",
mentions.GroupBy(g => g.UserKey)
.Select(p => string.Format(GroupFormat, p.First().User.Name,
String.Join("|",
p.Select(j => j.String)
.Concat(new [] { p.First().User.Name })
)
))
));
_customCachedPatternMentions = mentions.Select(p => p.Key).ToArray();
return _customCachedPattern;
}
public void AddValidationErrors(ControllerBase controller, IList<Tuple<string, string>> errors)
{
var groupedErrors = errors.GroupBy(x => x.Item1 ?? string.Empty);
foreach (var error in groupedErrors)
{
var state = controller.ViewData.ModelState[error.Key];
if (state != null && state.Errors.Count > 0) continue;
foreach (var message in error)
{
controller.ViewData.ModelState.AddModelError(
error.Key,
message.Item2);
}
}
}
public IList <string> CalculateWorstSellers(IList <Sale> sales)
{
if (!sales.Any())
{
return(new List <string>());
}
var salesBySalesman = sales
.GroupBy(sale => sale.Salesman)
.Select(group => new
{
Salesman = group.Key,
Total = group.Sum(sale => sale.Total)
}).ToList();
var minTotal = salesBySalesman.Min(x => x.Total);
return(salesBySalesman
.Where(sale => sale.Total.Equals(minTotal))
.Select(sale => sale.Salesman).ToList());
}
/// <summary>
/// Groups identical products together by increasing their quantity.
/// </summary>
/// <param name="products">The list of products to group.</param>
public static IList <ProcessOrderProduct> GroupDuplicates(this IList <ProcessOrderProduct> products)
{
products.CheckNotNull(nameof(products));
if (!products.Any())
{
return(products);
}
var grouped = products.GroupBy(x => new { x.Name, x.Price })
.Select(x => new ProcessOrderProduct()
{
Name = x.Key.Name,
Price = x.Key.Price,
Quantity = x.Sum(x => x.Quantity)
}).ToList();
products.Clear();
products.AddRange(grouped);
return(products);
}
protected override Dictionary <Product, IEnumerable <string> > GetValues(List <Product> objs)
{
ProductVariant productVariantAlias = null;
OptionValueData data = null;
IList <OptionValueData> values = _session.QueryOver <ProductOptionValue>()
.JoinAlias(value => value.ProductVariant, () => productVariantAlias)
.SelectList(builder => builder
.Select(value => value.Value).WithAlias(() => data.Value)
.Select(value => value.ProductOption.Id).WithAlias(() => data.OptionId)
.Select(() => productVariantAlias.Product.Id).WithAlias(() => data.ProductId)
).TransformUsing(Transformers.AliasToBean <OptionValueData>())
.List <OptionValueData>();
Dictionary <int, IEnumerable <string> > dictionary =
values.GroupBy(valueData => valueData.ProductId)
.ToDictionary(datas => datas.Key, datas => datas.Select(valueData => valueData.TermValue));
return(objs.ToDictionary(product => product,
product => dictionary.ContainsKey(product.Id) ? dictionary[product.Id] : Enumerable.Empty <string>()));
}
public static IList <StudentAttendanceSummary> Create(IList <StudentSectionAbsenceSummary> studentSectionAttendances, IList <Student> students, IList <ClassDetails> classes)
{
var stSectionAttsDic = studentSectionAttendances.GroupBy(x => x.StudentId).ToDictionary(x => x.Key, x => x.ToList());
var res = new List <StudentAttendanceSummary>();
foreach (var stSectionAtts in stSectionAttsDic)
{
var student = students.FirstOrDefault(x => x.Id == stSectionAtts.Key);
if (student == null)
{
continue;
}
res.Add(new StudentAttendanceSummary
{
Student = student,
ClassAttendanceSummaries = StudentClassAttendanceSummary.Create(stSectionAtts.Value, classes)
});
}
return(res);
}
private async Task <IEnumerable <JobDefinition> > SupersedeJobs(IList <Job> createdJobs, IEnumerable <JobDefinition> jobDefinitions)
{
IEnumerable <IGrouping <string, Job> > jobDefinitionGroups = createdJobs
.GroupBy(j => j.JobDefinitionId);
IEnumerable <JobDefinition> jobDefinitionsToSupersede = jobDefinitions
.GroupBy(x => x.Id)
.Select(x => x.First(y => y.Id == x.Key));
foreach (IGrouping <string, Job> jobDefinitionKvp in jobDefinitionGroups)
{
Job jobToSupersedeOthers = jobDefinitionKvp.First();
JobDefinition jobDefinition = jobDefinitionsToSupersede.First(m => m.Id == jobToSupersedeOthers.JobDefinitionId);
await CheckForSupersededAndCancelOtherJobs(jobToSupersedeOthers, jobDefinition);
}
return(jobDefinitionsToSupersede);
}
/// <summary>
/// Gets selected address attributes
/// </summary>
/// <param name="attributes">Attributes</param>
/// <returns>Selected address attributes</returns>
public virtual async Task <IList <AddressAttribute> > ParseAddressAttributes(IList <CustomAttribute> customAttributes)
{
var result = new List <AddressAttribute>();
if (!customAttributes.Any())
{
return(result);
}
foreach (var customAttribute in customAttributes.GroupBy(x => x.Key))
{
var attribute = await _addressAttributeService.GetAddressAttributeById(customAttribute.Key);
if (attribute != null)
{
result.Add(attribute);
}
}
return(result);
}
private async Task <User> GetRolesAndClaimsAsync(ApplicationUser appUser)
{
IList <string> roles = await userManager.GetRolesAsync(appUser);
IList <Claim> claims = await userManager.GetClaimsAsync(appUser);
User user = new User
{
Id = appUser.Id,
Username = appUser.UserName,
Email = appUser.Email,
Roles = roles.ToArray(),
Claims = claims.GroupBy(x => x.Type.ToString())
.Select(g => (key: g.Key, values: g.Select(k => k.Value).ToArray()))
.ToDictionary(k => k.key, k => k.values)
};
return(user);
}
}
private static void SetDownloadDependencies(IObjectWriter writer, IList <DownloadDependency> downloadDependencies)
{
if (!downloadDependencies.Any())
{
return;
}
writer.WriteArrayStart("downloadDependencies");
foreach (var dependency in downloadDependencies.GroupBy(dep => dep.Name).OrderBy(dep => dep.Key))
{
var version = string.Join(";", dependency.Select(dep => dep.VersionRange).OrderBy(dep => dep.MinVersion).Select(dep => dep.ToNormalizedString()));
writer.WriteObjectStart();
SetValue(writer, "name", dependency.Key);
SetValue(writer, "version", version);
writer.WriteObjectEnd();
}
writer.WriteArrayEnd();
}
private bool ValidateFiles(string directoryPath, IList <MigrationInfo> target)
{
_logger.LogInformation("Validate migrations directory: \"{DirectoryPath}\"", directoryPath);
var directory = new DirectoryInfo(directoryPath);
bool success = true;
foreach (var file in directory.GetFiles(Pattern))
{
var info = ValidateFileName(file);
if (info == null)
{
success = false;
continue;
}
target.Add(info);
}
var duplicateTimestamps = target.GroupBy(x => x.Timestamp).Where(x => x.Count() > 1).Select(x => x.Key).ToArray();
if (duplicateTimestamps.Any())
{
foreach (var timestamp in duplicateTimestamps)
{
_logger.LogWarning("Duplicate timestamp: {Timestamp}", timestamp);
}
_logger.LogError("Duplicate timestamps found. Please fix. Exit");
return(false);
}
if (!success)
{
_logger.LogError("Some files does not match suggested migration file pattern \"YYYYMMDDNN - migration name\". Exit");
}
return(success);
}
private void CreateTimelineForPackets <T>(IList <T> packets, int interval, Func <T, string> selector, Func <T, double> timestamp)
{
var paths = packets.Select(selector).ToHashSet();
var startTime = timestamp(packets.First());
var points = packets.GroupBy(p => (int)Math.Floor((timestamp(p) - startTime) / interval));
var timeTable = new DataTable();
timeTable.Columns.Add("Time", typeof(string));
foreach (var path in paths)
{
var col = new DataColumn(String.IsNullOrWhiteSpace(path) ? "<empty>" : path, typeof(int));
col.DefaultValue = 0;
timeTable.Columns.Add(col);
}
var lastPoint = 0;
foreach (var point in points)
{
for (int i = lastPoint + 1; i < point.Key; i++)
{ // add empty rows
timeTable.Rows.Add(i);
}
lastPoint = point.Key;
var row = timeTable.NewRow();
var data = point.GroupBy(selector).Select(x => (Key: x.Key, Count: x.Count()));
row["Time"] = point.Key;
foreach (var item in data)
{
var key = String.IsNullOrWhiteSpace(item.Key) ? "<empty>" : item.Key;
row[key] = item.Count;
}
timeTable.Rows.Add(row);
}
Console.WriteLine("Timeline:");
ConsoleTableBuilder.From(timeTable)
.WithFormat(ConsoleTableBuilderFormat.MarkDown)
.ExportAndWriteLine();
}
private ICollection <PlanTrackNumber> GetPlanTrackNumberByPredictData(string lotteryId, IList <PredictDataDto> data)
{
var planTrackNumbers = new List <PlanTrackNumber>();
var finalLotteryData = _lotteryDataAppService.GetFinalLotteryData(LotteryInfo.Id);
var cacheKey = string.Format(RedisKeyConstants.LOTTERY_PLANTRACK_DETAIL_KEY,
LotteryInfo.Id, _userMemberRank == MemberRank.Ordinary ?
LotteryConstants.SystemUser : _lotterySession.UserId, finalLotteryData.Period);
_cacheManager.Remove(cacheKey);
data.GroupBy(p => p.NormConfigId).ForEach(item =>
{
var planInfo = _normConfigQueryService.GetNormPlanInfoByNormId(item.Key, lotteryId);
var newestPredictDataDto = item.OrderByDescending(p => p.StartPeriod).First();
var normConfig = _normConfigQueryService.GetUserNormConfig(item.Key);
var planTrackNumber = new PlanTrackNumber()
{
NormId = normConfig.Id,
Sort = normConfig.Sort,
PlanId = planInfo.Id,
PlanName = planInfo.PlanName,
EndPeriod = newestPredictDataDto.EndPeriod,
StartPeriod = newestPredictDataDto.StartPeriod,
MinorCycle = newestPredictDataDto.MinorCycle,
PredictData = newestPredictDataDto.PredictedData,
CurrentPredictPeriod = newestPredictDataDto.CurrentPredictPeriod,
PredictType = planInfo.DsType,
HistoryPredictResults = GetHistoryPredictResults(item.OrderByDescending(p => p.StartPeriod), item.Key, normConfig.LookupPeriodCount, planInfo.PlanNormTable),
};
var rightCount = planTrackNumber.HistoryPredictResults.Count(p => p == 0);
var totleCount = planTrackNumber.HistoryPredictResults.Count(p => p != 2);
var currentScore = Math.Round((double)rightCount / totleCount, 2);
planTrackNumber.CurrentScore = currentScore;
WritePlanTrackNumbers(item, planInfo, currentScore);
planTrackNumbers.Add(planTrackNumber);
});
return(planTrackNumbers.OrderBy(p => p.Sort).ToList());
}
private async Task <IList <Price> > GetMergedPriceByPriceList(IList <CsvPrice> pricesWithPriceListIds)
{
if (!pricesWithPriceListIds.Any())
{
return(new List <Price>());
}
var existentPrices = new List <Price>();
var dictionary = pricesWithPriceListIds.GroupBy(x => x.PricelistId).ToDictionary(g => g.Key, g => g.ToArray());
foreach (var priceListId in dictionary.Keys)
{
var criteria = new PricesSearchCriteria
{
PriceListId = priceListId,
ProductIds = dictionary[priceListId].Select(x => x.ProductId).ToArray(),
Take = int.MaxValue,
};
var searchResult = await _pricingSearchService.SearchPricesAsync(criteria);
existentPrices.AddRange(searchResult.Results);
}
var result = new List <Price>();
foreach (var price in pricesWithPriceListIds)
{
var existPrice = existentPrices.FirstOrDefault(x => x.ProductId.EqualsInvariant(price.ProductId) && x.PricelistId.EqualsInvariant(price.PricelistId));
if (existPrice != null)
{
price.MergeFrom(existPrice);
}
result.Add(price);
}
return(result);
}
/// <summary>
///
/// </summary>
/// <param name="args"></param>
static void Main(string[] args)
{
IDataParser dataparser = new DataParser();
IList <SalesEntity> salesEntities = dataparser.JsonParse <SalesEntity>(@"C:\Users\benasm\salesValid.json").ToList();
ISalesInsight salesInsight = new SalesInsight();
salesInsight.LogRegisterStateChange(salesEntities);
DateTime startDateTime = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
var departmentsHourlyAggregated = salesEntities.GroupBy(saleEntity => new
{
saleEntity.StoreNumber,
saleEntity.Department,
DateWithHour = new DateTime(startDateTime.AddMilliseconds(saleEntity.OrderTime).Year,
startDateTime.AddMilliseconds(saleEntity.OrderTime).Month,
startDateTime.AddMilliseconds(saleEntity.OrderTime).Day,
startDateTime.AddMilliseconds(saleEntity.OrderTime).Hour, 0, 0)
}).Select(groupedData => new DepartmentHourlyAggregateEntity()
{
StoreNumber = groupedData.Key.StoreNumber,
Department = groupedData.Key.Department,
DateWithHour = groupedData.Key.DateWithHour,
TotalAmount = groupedData.Sum(d => d.Amount)
}).ToList();
var storeHourlyAggregated = departmentsHourlyAggregated.GroupBy(departmentsHourlyAggregate => new
{
departmentsHourlyAggregate.StoreNumber,
departmentsHourlyAggregate.DateWithHour
}).Select(groupedData => new StoreHourlyAggregateEntity()
{
StoreNumber = groupedData.Key.StoreNumber,
DateWithHour = groupedData.Key.DateWithHour,
TotalAmount = groupedData.Sum(d => d.TotalAmount)
}).OrderBy(d => d.DateWithHour).ToList();
salesInsight.LogDepartmentSaleDecrease(departmentsHourlyAggregated, storeHourlyAggregated);
salesInsight.LogHighestRelativePercentIncrease(departmentsHourlyAggregated, storeHourlyAggregated);
Console.Write("Press any key to close");
Console.Read();
}
// <summary>
// Validates the specified enumeration type as a whole.
// </summary>
internal override void Validate()
{
base.Validate();
var enumUnderlyingType = UnderlyingType as ScalarType;
if (enumUnderlyingType == null ||
!Helper.IsSupportedEnumUnderlyingType(enumUnderlyingType.TypeKind))
{
AddError(
ErrorCode.InvalidEnumUnderlyingType,
EdmSchemaErrorSeverity.Error,
Strings.InvalidEnumUnderlyingType);
}
else
{
Debug.Assert(!_enumMembers.Any(m => !m.Value.HasValue), "member values should have been fixed up already.");
// Check for underflows and overflows
var invalidEnumMembers = _enumMembers
.Where(m => !Helper.IsEnumMemberValueInRange(enumUnderlyingType.TypeKind, (long)m.Value));
foreach (var invalidEnumMember in invalidEnumMembers)
{
invalidEnumMember.AddError(
ErrorCode.EnumMemberValueOutOfItsUnderylingTypeRange,
EdmSchemaErrorSeverity.Error,
Strings.EnumMemberValueOutOfItsUnderylingTypeRange(
invalidEnumMember.Value, invalidEnumMember.Name, UnderlyingType.Name));
}
}
// Check for duplicate enumeration members.
if (_enumMembers.GroupBy(o => o.Name).Where(g => g.Count() > 1).Any())
{
AddError(
ErrorCode.DuplicateEnumMember,
EdmSchemaErrorSeverity.Error,
Strings.DuplicateEnumMember);
}
}
private List <MinuteBarRequestKeyDto> DeduplicateKeys(IList <MinuteBarRequestKeyDto> filteredKeys)
{
var deduplicatedKeys = new List <MinuteBarRequestKeyDto>();
var grps = filteredKeys.GroupBy(x => x.Figi);
foreach (var grp in grps)
{
var dedupe = grp.GroupBy(x => x.Date.Date).Select(x => x.FirstOrDefault()).Where(x => x != null)
.ToList();
if (!dedupe.Any())
{
continue;
}
deduplicatedKeys.AddRange(dedupe);
}
return(deduplicatedKeys);
}
public async Task <ActionResult> ViewSalesData()
{
try
{
HttpPostedFileBase salesDataFile = Request.Files.Count > 0 ? Request.Files[0] : null;
IList <string> csvData = CSVHelper.ReadCSVFile(salesDataFile);
if (csvData == null)
{
ViewBag.Errors = new[] { "Unable to read CSV file." };
}
IList <VehicleDetail> vehicleDetails = CSVHelper.ConvertToModel(csvData);
ViewBag.MostSoldVehicle = vehicleDetails.GroupBy(vd => vd.Vehicle).GetHighesCountGroup();
return(View("Results", vehicleDetails));
}
catch (Exception ex)
{
Response.StatusCode = 500;
return(View("Error"));
}
}
public static List <FoodChargeCheckDTO> ToExtendedList(this IList <FoodChargeCheck> pLstObjCheckList)
{
return(pLstObjCheckList.GroupBy(x => new { SellerId = x.SellerId, SellerCode = x.Seller.Code, SellerName = x.Seller.Name }).Select(y => new FoodChargeCheckDTO()
{
SellerId = y.Key.SellerId,
SellerCode = y.Key.SellerCode,
SellerName = y.Key.SellerName,
Lines = y.Select(z => new FoodChargeCheckLineDTO()
{
Id = z.Id,
BatchNumber = z.BatchNumber,
BatchDate = z.BatchDate,
ExpirationDate = z.ExpirationDate,
FoodCharge = z.FoodCharge,
FoodDeliveries = z.FoodDeliveries,
AlfalfaDeliveries = z.AlfalfaDeliveries,
ApplyFoodCharge = z.ApplyFoodCharge
}).ToList()
}).ToList());
}
public override SKSize Measure(IList <HierarchicalNode> elements, SKSize availableSize)
{
heightByLevel.Clear();
float maxWidth = 0;
float maxHeight = 0;
List <HierarchicalNode> allreadyPassed = new List <HierarchicalNode>();
foreach (var group in elements.GroupBy(n => n.Level))
{
maxWidth = Measure(group.Key, group, maxWidth, availableSize, allreadyPassed);
float maxHeightByLevel = 0;
foreach (var element in group)
{
maxHeightByLevel = Math.Max(maxHeightByLevel, element.DesiredSize.Height);
}
heightByLevel.Add(group.Key, maxHeightByLevel);
maxHeight += maxHeightByLevel + VerticalSpacing;
}
totalSize = new SKSize(maxWidth - HorizontalSpacing, maxHeight - VerticalSpacing);
return(totalSize);
}
public static IList <GridData> CleanupRawData(this FileReaderResult rawData)
{
IList <GridData> cleanupColumn = rawData.Data;
if (rawData.Titles != null && rawData.Titles.Any() && !rawData.Titles.All(ttl => String.IsNullOrEmpty(ttl)))
{
cleanupColumn = rawData
.Titles
.Select((ttl, idx) => new { Ordinal = idx + 1, Item = ttl })
.Where(ttl => !String.IsNullOrEmpty(ttl.Item))
.Join(rawData.Data, o => o.Ordinal, i => i.Column, (o, i) => i)
.ToList();
}
return(cleanupColumn
.GroupBy(prm => prm.Row)
.Select(grp => grp.Select(item => item))
.Where(grd => !grd.Aggregate(true, (p, n) => p && String.IsNullOrEmpty(n.CellValue)))
.SelectMany(grd => grd)
.ToList());
}
public void AddOrUpdateSessionData(string clientToken, IList <PocketDDD.Models.UserSessionData> sessionData)
{
if (sessionData == null || sessionData.Count == 0)
{
return;
}
var sessionDataForEvents = sessionData.GroupBy(x => x.eventId);
foreach (var eventGroup in sessionDataForEvents)
{
var userInfo = GetUserEventInfo(eventGroup.Key);
var dddEvent = eventsService.GetServerEventData(eventGroup.Key);
var eventDetail = eventsService.GetEventDetail(dddEvent);
if (dddEvent.IsActive)
{
addOrUpdateSessionData(eventGroup.Key, eventDetail, userInfo != null ? userInfo.UserName : "", userInfo != null ? userInfo.UserToken : null, clientToken, eventGroup.ToList());
}
}
}
public void TestCodeCoverageSelection()
{
this.RunContext.IsDataCollectionEnabled = true;
this.Executor.RunTests(
new VSTestCase[] { CreateTestCase("Test1", DefaultSource), CreateTestCase("Test2", DefaultSource) },
this.RunContext,
this.FrameworkHandle
);
IList <MockBoostTestRunner> runners = this.RunnerFactory.ProvisionedRunners.OfType <MockBoostTestRunner>().ToList();
Assert.That(runners.GroupBy(runner => runner.Source).Count(), Is.EqualTo(1));
MockBoostTestRunner testRunner = runners.FirstOrDefault(runner => runner.RunCount == 1);
Assert.That(testRunner, Is.Not.Null);
// All selected tests are executed
Assert.That(testRunner.Args.First().Tests.Count, Is.EqualTo(2));
}
private EstatisticaAdocante GerarEstatisticasUsamAdocante(IList <Inscricao> inscricoes)
{
var grupo = inscricoes.GroupBy(x => x.Pessoa.UsaAdocanteDiariamente);
var estatistica = new EstatisticaAdocante();
foreach (var item in grupo)
{
if (item.Key)
{
estatistica.Usam = item.Count();
estatistica.UsamPresentes = item.Count(x => x.ConfirmadoNoEvento);
}
else
{
estatistica.NaoUsam = item.Count();
estatistica.NaoUsamPresentes = item.Count(x => x.ConfirmadoNoEvento);
}
}
return(estatistica);
}
public static IList <StudentGradingByTypeStatsViewData> Create(IList <ClassAnnouncement> announcements
, IList <StudentAnnouncementDetails> studentAnnouncements, IList <ClaimInfo> claims)
{
var res = new List <StudentGradingByTypeStatsViewData>();
announcements = announcements.Where(x => x.ClassAnnouncementTypeRef.HasValue).ToList();
var dicbyType = announcements.GroupBy(x => x.ClassAnnouncementTypeRef).ToDictionary(x => x.Key, x => x.ToList());
foreach (var typeAnns in dicbyType)
{
var ann = typeAnns.Value.First();
Trace.Assert(ann.ClassAnnouncementTypeRef.HasValue);
res.Add(new StudentGradingByTypeStatsViewData
{
ClassAnnouncementTypeId = ann.ClassAnnouncementTypeRef.Value,
ClassAnnouncementTypeName = ann.ClassAnnouncementTypeName,
StudentGradingStats = StudentGradingStatsViewData.Create(typeAnns.Value, studentAnnouncements, claims)
});
}
return(res);
}
public List <BLL_ContractTypes> Transform(IList <grs_VGrsContractType> contractType)
{
List <BLL_ContractTypes> data = new List <BLL_ContractTypes>();
if (contractType.Count > 0)
{
contractType.GroupBy(a => a.RowId).ToList().ForEach((sContract) =>
{
var contractGroupData = sContract.ToList();
contractGroupData.ForEach((summary) =>
{
data.Add(new BLL_ContractTypes()
{
name = Convert.ToString(summary.AssumedName), value = Convert.ToString(summary.Code), group = Convert.ToString(summary.Exposuretype), isActive = (Convert.ToBoolean(summary.AssumedFlag) && Convert.ToBoolean(summary.Active))
});
});
});
return(data.ToList());
}
return(null);
}
private EstatisticaSexo GerarEstatisticasSexo(IList <Inscricao> inscricoes)
{
var inscricoesPorSexo = inscricoes.GroupBy(x => x.Pessoa.Sexo);
var estatistica = new EstatisticaSexo();
foreach (var sexo in inscricoesPorSexo)
{
if (sexo.Key == SexoPessoa.Feminino)
{
estatistica.Mulheres = sexo.Count();
estatistica.MulheresPresentes = sexo.Count(x => x.ConfirmadoNoEvento);
}
else if (sexo.Key == SexoPessoa.Masculino)
{
estatistica.Homens = sexo.Count();
estatistica.HomensPresentes = sexo.Count(x => x.ConfirmadoNoEvento);
}
}
return(estatistica);
}
protected override void DoStart()
{
_parameterMetaDataList = _flatParameterMetaDataRepository.All().ToList();
_parameterMetaDataList.Each(parameterMetaData =>
{
parameterMetaData.ParentContainerPath = _flatContainerRepository.ContainerPathFrom(parameterMetaData.ContainerId).ToString();
//Use clone here to ensure that we are not modifying the reference stored in the repository
var valueOrigin = _valueOriginRepository.FindBy(parameterMetaData.ValueOriginId).Clone();
parameterMetaData.ValueOrigin = valueOrigin;
//update only if available in db
parameterMetaData.ContainerCriteria = containerCriteriaFor(parameterMetaData.ContainerId, parameterMetaData.ParameterName);
});
//now cache the parameter meta data by container path
foreach (var parameterValueMetaDataGroup in _parameterMetaDataList.GroupBy(x => x.ParentContainerPath))
{
_parameterMetaDataCacheByContainer.Add(parameterValueMetaDataGroup.Key, new List <TParameterMetaData>(parameterValueMetaDataGroup));
}
}
void Validate(IList <VisualStateGroup> groups)
{
// If we have 1 group, no need to worry about duplicate group names
if (groups.Count > 1)
{
if (groups.GroupBy(vsg => vsg.Name).Any(g => g.Count() > 1))
{
throw new InvalidOperationException("VisualStateGroup Names must be unique");
}
}
// State names must be unique within this group list, so pull in all
// the states in all the groups, group them by name, and see if we have
// and duplicates
if (groups.SelectMany(group => group.States)
.GroupBy(state => state.Name)
.Any(g => g.Count() > 1))
{
throw new InvalidOperationException("VisualState Names must be unique");
}
}
private EstatisticaDiabeticos GerarEstatisticasDiabeticos(IList <Inscricao> inscricoes)
{
var grupo = inscricoes.GroupBy(x => x.Pessoa.EhDiabetico);
var estatistica = new EstatisticaDiabeticos();
foreach (var item in grupo)
{
if (item.Key)
{
estatistica.Sao = item.Count();
estatistica.SaoPresentes = item.Count(x => x.ConfirmadoNoEvento);
}
else
{
estatistica.NaoSao = item.Count();
estatistica.NaoSaoPresentes = item.Count(x => x.ConfirmadoNoEvento);
}
}
return(estatistica);
}
