public bool ValidAttributesFor(string table, string featureType, IEnumerable<FeatureActions> actions) { if (string.IsNullOrEmpty(featureType)) { return false; } featureType = featureType.ToLower(); if (featureType == "affected area" && actions == null) { return true; } if (string.IsNullOrEmpty(table)) { return false; } table = table.ToLower(); if (actions == null) { return false; } switch (table) { case "poly": return actions.All( x => !string.IsNullOrEmpty(x.Action) && x.Treatments.All(t => !string.IsNullOrEmpty(t.Treatment))); case "point": if (actions.Count() != 1) { return false; } if (new[] {"guzzler", "fish passage structure"}.Contains(featureType)) { return actions.All(x => !string.IsNullOrEmpty(x.Action) && !string.IsNullOrEmpty(x.Type)); } return actions.All(x => !string.IsNullOrEmpty(x.Description)); case "line": if (actions.Count() != 1) { return false; } return actions.All(x => !string.IsNullOrEmpty(x.Action) && !string.IsNullOrEmpty(x.Type)); } return false; }
/// <summary> /// Exports specified stops to serializable stop information. /// </summary> /// <param name="stops">The reference to the collection of stops to be exported.</param> /// <param name="capacitiesInfo">The reference to capacities info object to be used /// for retrieving custom order properties for stops.</param> /// <param name="orderCustomPropertiesInfo">The reference custom order properties info /// object.</param> /// <param name="addressFields">The reference to address fields object to be used /// for retrieving custom order properties for stops.</param> /// <param name="solver">The reference to VRPSolver to be used for retrieving /// curb approach policies for stops.</param> /// <param name="orderPropertiesFilter">Function returning true for custom order /// property names which should not be exported.</param> /// <returns>A reference to the collection of serializable stop information objects. /// </returns> public static IEnumerable<StopInfo> ExportStops( IEnumerable<Stop> stops, CapacitiesInfo capacitiesInfo, OrderCustomPropertiesInfo orderCustomPropertiesInfo, AddressField[] addressFields, IVrpSolver solver, Func<string, bool> orderPropertiesFilter = null) { Debug.Assert(stops != null); Debug.Assert(stops.All(stop => stop != null)); Debug.Assert(stops.All(stop => stop.Route != null)); Debug.Assert(capacitiesInfo != null); Debug.Assert(orderCustomPropertiesInfo != null); Debug.Assert(addressFields != null); if (!stops.Any()) { return Enumerable.Empty<StopInfo>(); } var capacityProperties = Order.GetPropertiesInfo(capacitiesInfo); var addressProperties = Order.GetPropertiesInfo(addressFields); var customProperties = Order.GetPropertiesInfo(orderCustomPropertiesInfo); var exportOrderProperties = _CreateExportOrderProperties( capacitiesInfo, orderCustomPropertiesInfo, addressFields, orderPropertiesFilter); // Make a dictionary for mapping routes to collection of sorted route stops. var routesSortedStops = stops .Select(stop => stop.Route) .Distinct() .ToDictionary(route => route, route => CommonHelpers.GetSortedStops(route)); // Prepare result by exporting each stop individually. var settings = CommonHelpers.GetSolverSettings(solver); var result = stops .Select(stop => _ExportStop( stop, routesSortedStops[stop.Route], exportOrderProperties, addressProperties, capacityProperties, customProperties, settings)) .ToList(); return result; }
/// <summary> /// Create an aggregations object. /// </summary> /// <param name="aggregators">Sets the aggregations.</param> public Aggregations(IEnumerable<IAggregation> aggregators) { if (aggregators == null || aggregators.All(x => x == null)) throw new ArgumentNullException("aggregators", "Aggregations requires at least one aggregator."); Aggregators = aggregators.Where(x => x != null); }
/// <summary> /// Create a rescore request. /// </summary> /// <param name="rescoreQueries">The queries to run that will rescore the documents.</param> public Rescore(IEnumerable<RescoreQuery> rescoreQueries) { if (rescoreQueries == null || rescoreQueries.All(x => x == null)) throw new ArgumentNullException("rescoreQueries", "RescoreRequest requires at least one rescore query."); RescoreQueries = rescoreQueries.Where(x => x != null); }
public static bool AreAllKeysUp(this KeyboardState keyboardState, IEnumerable<Keys> keys) { keyboardState.ThrowIfNull("keyboardState"); keys.ThrowIfNull("keys"); return keys.All(keyboardState.IsKeyUp); }
public override Func<DataASTMutable.WarewolfAtom, bool> CreateFunc(IEnumerable<DataASTMutable.WarewolfAtom> values, IEnumerable<DataASTMutable.WarewolfAtom> warewolfAtoms, IEnumerable<DataASTMutable.WarewolfAtom> to, bool all) { if (all) return a => values.All(x => DataASTMutable.CompareAtoms(a,x)==0); return a => values.Any(x => DataASTMutable.CompareAtoms(a, x) == 0); }
/// <summary> /// Queries the plugwise database for the yield in the given month. /// </summary> /// <param name="from">start point, inclusive</param> /// <param name="to">start point, inclusive</param> /// <returns></returns> public IList<YieldAggregate> Get5minPlugwiseYield(DateTime from, IEnumerable<int> applianceIds) { // Querying on a datetime fails somehow // As a workaround we list the complete table and use linq to objects for the filter // This presents some scalability issues and should be looked in to. IList<Minute_Log_5> latest; if (!applianceIds.Any()) latest = LoadAll5minData(); else latest = Load5minApplianceData(applianceIds); Console.WriteLine("Loading 5minute plugwise production data since {0}", from); var applianceLog = (from logline in latest where logline.LogDate >= @from.AddHours(-1) from log in Get5minParts(logline) where log.Date >= @from && log.Yield > 0.0 group log by log.Date into logbydate orderby logbydate.Key where applianceIds.All( appliance => logbydate.Any(log => log.ApplianceID == appliance)) select new YieldAggregate( date: logbydate.Key, yield: logbydate.Sum(l => l.Yield), duration: logbydate.First().Duration) ).ToList(); return applianceLog; }
public static bool CanZip(IEnumerable<IProtectAttachment> attachments) { if (!PolicyBridge.IsEnabled("InteractiveProtectAllowUsersToCompressToZip")) return false; return !attachments.All(x => x.FileType == FileType.ZIP); }
public IReadOnlyCollection<string> GetBlockWrapper(IEnumerable<string> code) { // If the code doesn't have any braces, surround it in a ruleset so that properties are valid. if (code.All(t => t.IndexOfAny(new[] { '{', '}' }) == -1)) return new[] { ".GeneratedClass-" + Guid.NewGuid() + " {", "}" }; return null; }
public void Prepend( IEnumerable<object> sut, object[] items ) { var prepended = sut.Prepend( items ); Assert.Equal( sut.Count() + items.Length, prepended.Count() ); Assert.True( sut.All( x => prepended.Contains( x ) ) ); Assert.True( items.All( x => prepended.Contains( x ) ) ); }
/// <summary> /// Creates a source filter to include multiple fields. /// </summary> /// <param name="includeFields"></param> public SourceFilter(IEnumerable<string> includeFields) { if (includeFields == null || includeFields.All(x => string.IsNullOrWhiteSpace(x))) throw new ArgumentNullException("includeFields", "SourceFilter requires at least one field to include in this constructor."); IncludeFields = includeFields; }
/// <summary> /// Create a span_near query. /// </summary> /// <param name="clauses">The span queries used to find documents.</param> public SpanNearQuery(IEnumerable<SpanQueryBase> clauses) { if (clauses == null || clauses.All(x => x == null)) throw new ArgumentNullException("clauses", "SpanNearQuery requires at least one span query for clauses."); Clauses = clauses; }
private bool AddNewTorgetItems(IEnumerable<HtmlNode> items) { foreach (var torgetItem in items.Where(IsNewTorgetItem).Select(CreateTorgetItem)) _items.Add(torgetItem); return items.All(IsNewTorgetItem); }
public void Save(IEnumerable<Sim> simList) { if (simList.Count() == 0) return; using (MySqlConnection conn = new MySqlConnection("server = localhost; user id = root; password = ; database = test")) { conn.Open(); var cmd = conn.CreateCommand(); cmd.CommandText = "set character set 'utf8'"; cmd.ExecuteNonQuery(); var cmdText = @"select * from quest_sim"; cmd = conn.CreateCommand(); cmd.CommandText = cmdText; var quest_sim = @"INSERT INTO quest_sim SET quest_id=?quest_id,compare_id=?compare_id,value=?value,start=?start"; //路径 simList.All(sim => { cmd = conn.CreateCommand(); cmd.CommandText = quest_sim; cmd.Parameters.AddWithValue("?quest_id", sim.QuestID); cmd.Parameters.AddWithValue("?compare_id", sim.CompareID); cmd.Parameters.AddWithValue("?value", sim.Value); cmd.Parameters.AddWithValue("?start", sim.StartCity); cmd.ExecuteNonQuery(); return true; }); } }
public IndicesBoost(IEnumerable<IndexBoost> boostedIndices) { if (boostedIndices == null || boostedIndices.All(x => x == null)) throw new ArgumentNullException("boostedIndices", "IndicesBoost requires at least one IndexBoost."); BoostedIndices = boostedIndices.Where(x => x != null); }
/// <summary> /// Create a suggest request body document. /// </summary> /// <param name="suggestors">Sets the fields to get suggests from.</param> public Suggest(IEnumerable<ISuggester> suggestors) { if (suggestors == null || suggestors.All(x => x == null)) throw new ArgumentNullException("suggestors", "Suggest requires at least one field suggest."); Suggestors = suggestors.Where(x => x != null); }
private void ValidateUniqueCurrency(IEnumerable<Currency> otherCurrencies, ref ModelStateDictionary modelStateDictionary) { if (otherCurrencies.All(oc => oc.CurrencyType != CurrencyType)) return; modelStateDictionary.AddModelError(BaseCache.CurrencyTypeField, String.Format(ValidationResource.Global_OwnUnique_ErrorMessage, FieldResource.Global_Currency_Name)); }
/// <summary> /// Initializes a new instance of the <see cref="CharacterTemplate"/> class. /// </summary> /// <param name="templateTable">The template table.</param> /// <param name="inventory">The inventory.</param> /// <param name="equipment">The equipment.</param> /// <param name="quests">The quests.</param> /// <param name="knownSkills">The known skills.</param> /// <exception cref="ArgumentNullException"><paramref name="templateTable" /> is <c>null</c>.</exception> /// <exception cref="ArgumentNullException"><paramref name="inventory" /> is <c>null</c>.</exception> /// <exception cref="ArgumentNullException"><paramref name="equipment" /> is <c>null</c>.</exception> /// <exception cref="ArgumentNullException"><paramref name="knownSkills" /> is <c>null</c>.</exception> public CharacterTemplate(ICharacterTemplateTable templateTable, IEnumerable<CharacterTemplateInventoryItem> inventory, IEnumerable<CharacterTemplateEquipmentItem> equipment, IEnumerable<IQuest<User>> quests, IEnumerable<SkillType> knownSkills) { _templateTable = templateTable; if (templateTable == null) throw new ArgumentNullException("templateTable"); if (inventory == null) throw new ArgumentNullException("inventory"); if (equipment == null) throw new ArgumentNullException("equipment"); if (knownSkills == null) throw new ArgumentNullException("knownSkills"); // Compact all the collections given to us to ensure they are immutable and have minimal overhead _inventory = inventory.ToCompact(); _equipment = equipment.ToCompact(); _quests = quests.ToCompact(); _knownSkills = knownSkills.ToCompact(); // Assert values are valid Debug.Assert(_inventory.All(x => x != null)); Debug.Assert(_equipment.All(x => x != null)); Debug.Assert(_quests.All(x => x != null)); Debug.Assert(_knownSkills.All(EnumHelper<SkillType>.IsDefined), string.Format("One or more SkillTypes for CharacterTemplate `{0}` are invalid!", this)); if (log.IsInfoEnabled) log.InfoFormat("Loaded CharacterTemplate `{0}`.", this); }
static XDocument MergeXml(IEnumerable<XDocument> inputs) { // What assembly is this? var assemblyName = GetAssemblyName(inputs.First()); if (!inputs.All(input => GetAssemblyName(input) == assemblyName)) { throw new Exception("All input files must be for the same assembly."); } // Merge all the member documentation into a single list. var mergedMembers = from input in inputs from member in input.Element("doc").Element("members").Elements() where !IsNamespace(member) select member; // Remove documentation tags that Intellisense does not use, to minimize the size of the shipping XML files. RemoveUnwantedElements(mergedMembers); // Generate new Intellisense XML. return new XDocument( new XElement("doc", new XElement("assembly", new XElement("name", assemblyName) ), new XElement("members", mergedMembers ) ) ); }
internal RepositoryVersions( IEnumerable<TagCommit> collected, StringBuilder errors, ReleaseTagVersion startingVersionForCSemVer, bool checkCompactExistingVersions ) { Debug.Assert( collected.All( c => c.ThisTag != null ) ); _versions = collected.OrderBy( t => t.ThisTag ).ToList(); if( _versions.Count > 0 ) { var first = _versions[0].ThisTag; if( checkCompactExistingVersions && startingVersionForCSemVer == null && !first.IsDirectPredecessor( null ) ) { errors.AppendFormat( "First existing version is '{0}' (on '{1}'). One or more previous versions are missing.", first, _versions[0].CommitSha ) .AppendLine(); } for( int i = 0; i < _versions.Count - 1; ++i ) { var prev = _versions[i].ThisTag; var next = _versions[i + 1].ThisTag; if( next.Equals( prev ) ) { errors.AppendFormat( "Version '{0}' is defined on '{1}' and '{2}'.", prev, _versions[i].CommitSha, _versions[i + 1].CommitSha ) .AppendLine(); } else if( checkCompactExistingVersions && !next.IsDirectPredecessor( prev ) ) { errors.AppendFormat( "Missing one or more version(s) between '{0}' and '{1}'.", prev, next ) .AppendLine(); } } } }
private bool IsRelationshipValid([NotNull] IModelRelationship relationship) { var sourceNode = GetNode(relationship.Source); var targetNode = GetNode(relationship.Target); return(_modelRuleProviders?.All(i => i.IsRelationshipTypeValid(relationship.Stereotype, sourceNode, targetNode)) == true); }
public IdsQuery(IEnumerable<string> documentIds) { if (documentIds == null || documentIds.All(x => string.IsNullOrWhiteSpace(x))) throw new ArgumentNullException("documentIds", "IdsQuery requires at least one document id."); DocumentIds = documentIds; }
/// <summary> /// Create a script_field value. /// </summary> /// <param name="fields">The fields to create, and the scripts to create them with.</param> public ScriptFieldRequest(IEnumerable<ScriptField> fields) { if (fields == null || fields.All(x => x == null)) throw new ArgumentNullException("fields", "ScriptFields requires at least one field."); Fields = fields.Where(x => x != null); }
/// <summary> /// Create the highlighter. /// </summary> /// <param name="fieldHighlighters">Sets the fields to highlight.</param> public Highlighter(IEnumerable<FieldHighlighter> fieldHighlighters) { if (fieldHighlighters == null || fieldHighlighters.All(x => x == null)) throw new ArgumentNullException("fieldHighlighters", "Highlighter requires at least one field highlighter."); FieldHighlighters = fieldHighlighters.Where(x => x != null); }
public async void SavePackageSources(IEnumerable<IPackageSource> packageSources) { if (_busy) return; _busy = true; await Task.Run(() => { foreach (var packageSource in _packageSources.ToArray()) { if (packageSources.All(n => n != packageSource)) { Remove(packageSource); } } foreach (var packageSource in packageSources.ToArray()) { if (!_packageSources.Any(n => n.Name == packageSource.Name && n.Location == packageSource.Location && n.Provider == packageSource.Provider)) { Add(packageSource); } } }); Reload(); _busy = false; }
/// <summary> /// Loads the given target faces /// </summary> public virtual void SetTargetFaces(IEnumerable<ITargetFace> faces) { if (!faces.All(x => x is IFaceModelTargetFace)) throw new ArgumentException("All target faces must implement IFaceModelTargetFace!"); this.SetTargetFaces(faces.Cast<IFaceModelTargetFace>()); }
public void Purge(IEnumerable<int> livingIds) { foreach (var idToRemove in this.elementMap.Keys.Where(k => livingIds.All(id => id != k)).ToArray()) { this.elementMap.Remove(idToRemove); } }
private static IEnumerable<Variant> GenerateVariants(Variant variant, Potter aBook, IEnumerable<Variant> alreadyGenerated) { return variant.Piles .Where(pile => !pile.Contains(aBook)) .Select(pile => CreateNewVariant(variant, pile, aBook)) .Where(newVariant => alreadyGenerated.All(v => !v.Equals(newVariant))); }
public Facets(IEnumerable<IFacet> facetGenerators) { if (facetGenerators == null || facetGenerators.All(x => x == null)) throw new ArgumentNullException("facetGenerators", "Facets requires at least one facet generator."); FacetGenerators = facetGenerators.Where(x => x != null); }
public static ValidationResult Create(RuleValidator validator, RuleValidatorContext context, IList<Object> parameterValues, object messageKey, IEnumerable<ValidationResult> nestedValidationResults = null) { string message = string.Empty; var messageService = new MessageService(); if (String.IsNullOrEmpty(validator.Message)) { var messageContext = new MessageContext(context, validator.GetType(), validator.Negate, validator.MessageStoreName, messageKey, validator.MessageFormatter); message = messageService.GetDefaultMessageAndFormat(messageContext, parameterValues); } else { //Since the message was supplied, don't get the default message from the store, just format it message = messageService.FormatMessage(validator.Message, context, parameterValues, validator.MessageFormatter); } //Override level if all the nested validation errors are Warnings if (nestedValidationResults != null && nestedValidationResults.All(vr => vr.Level == ValidationLevelType.Warn)) { return new ValidationResult(context.PropertyInfo, message, ValidationLevelType.Warn, context.PropertyValue, nestedValidationResults); } else { return new ValidationResult(context.PropertyInfo, message, context.Level, context.PropertyValue, nestedValidationResults); } //return new ValidationResult(context.PropertyInfo, message, context.Level, context.PropertyValue, nestedValidationResults); }
/// <summary> /// Creates a range facet, some combination of key/value field/script values are expected. /// </summary> /// <param name="facetName"></param> /// <param name="rangeBuckets"></param> public RangeFacet(string facetName, IEnumerable<RangeBucket> rangeBuckets) : this(facetName) { if (rangeBuckets == null || rangeBuckets.All(x => x == null)) throw new ArgumentNullException("rangeBuckets", "RangeFacet requires at least one range bucket."); RangeBuckets = rangeBuckets.Where(x => x != null); }
protected virtual void ProcessNewResult(OptimizationResult result) { // check if the incoming result is not the initial seed if (result.Id > 0) { if (Constraints?.All(constraint => constraint.IsMet(result.JsonBacktestResult)) != false) { if (Target.MoveAhead(result.JsonBacktestResult)) { Solution = result; Target.CheckCompliance(); } } } }
/// <summary> /// List repositories with ignored repositories removed. /// </summary> /// <param name="repositoriesToIgnore">A collection of Regex for repository names to ignore.</param> /// <returns></returns> public IEnumerable <GitRepository> GetRepositories(IEnumerable <Regex> repositoriesToIgnore = null) { Logger.Trace("Entering"); var info = $"RepositoriesToIgnore: {(repositoriesToIgnore == null ? "Null" : "Not Null")}"; var result = WaitAndRetryPolicyAsync.ExecuteAndCaptureAsync( _ => _client.Value.GetRepositoriesAsync(_vsTsTool.ProjectName), MakeContext(info) ).Result; HandlePolicyResult(result, info); var results = result.Result; var output = results .Where(x => repositoriesToIgnore?.All(y => !y.IsMatch(x.Name)) != false); Logger.Trace("Exiting"); return(output); }
public override bool IsSatisfiedBy(ITypeElement typeElement) { return(moduleBasedOnRegistration.IsSatisfiedBy(typeElement) && basedOnRegistrations.All(registration => registration.IsSatisfiedBy(typeElement))); }
private bool AllActivitiesBelongToSameCard(IEnumerable <Activity> activities) { var cardId = activities.First().CardId; return(activities.All(a => a.CardId == cardId)); }
public static bool forall <T>(Func <T, bool> predicate, IEnumerable <T> source) { return(source.All(predicate)); }
private static bool AllCharsInDictionary(IEnumerable <char> c, IReadOnlyDictionary <char, byte> d) => c.All(d.ContainsKey);
public static IComparisonResult Includes <T>(this IEnumerable <T> collection1, IEnumerable <T>?collection2) => Test.Collection(collection1) ?? Test.Collection(collection2) ?? ComparisonResult.FromBoolean(collection2?.All(c => collection1.Contains(c)), "First collection does not contain all elements of second collection");
private static bool IsValidSetOfNodes(IEnumerable <IProjectTree> treeNodes) { Requires.NotNull(treeNodes, nameof(treeNodes)); return(treeNodes.All(node => node.Flags.Contains(DependencyTreeFlags.Dependency | DependencyTreeFlags.SupportsBrowse))); }
private static bool HasJustAllFlattenableOperator(IEnumerable <ResultOperatorBase> resultOperators) { return(resultOperators.All(x => FlattenableResultOperators.Contains(x.GetType()))); }
/// <summary> /// Проверить ошибки на корректность /// </summary> protected static bool ValidateCollection <T>(IEnumerable <T> collection) => collection?.All(t => t != null) == true;
public override Func<DataASTMutable.WarewolfAtom, bool> CreateFunc(IEnumerable<DataASTMutable.WarewolfAtom> values, IEnumerable<DataASTMutable.WarewolfAtom> warewolfAtoms, IEnumerable<DataASTMutable.WarewolfAtom> to, bool all) { if (all) return a => values.All(x => !a.ToString().ToLower(CultureInfo.InvariantCulture).StartsWith(x.ToString().ToLower(CultureInfo.InvariantCulture))); return a => values.Any(x => !a.ToString().ToLower(CultureInfo.InvariantCulture).StartsWith(x.ToString().ToLower(CultureInfo.InvariantCulture))); }
/// <summary> /// Contains All /// Checks whether a list contains all values /// </summary> /// <typeparam name="T">List Generic Template</typeparam> /// <param name="source">Source IEnumerable</param> /// <param name="values">Values to be contained in the source collection</param> /// <returns>True if source contains all values, otherwise false</returns> public static bool ContainsAll <T>(this IEnumerable <T> source, IEnumerable <T> values) { return(values.All(value => source.Contains(value))); }
public static bool ArchiveAllDownloaded(IEnumerable <string> archiveCodes) { lock (MangaCodeHash) return(archiveCodes?.All(e => MangaCodeHash.Contains(e)) ?? false); }
public static bool AllAndSelfNotNull <T>(this IEnumerable <T> source) => source?.All(value => value != null) ?? false;
public virtual bool IsValid(IEnumerable <T> model) { _validationResults = Validate(model); return(_validationResults?.All(r => r.IsValid) == true); }
private bool IsEmptyChange(IEnumerable <TextEdit> changes) => changes.All(x => string.IsNullOrEmpty(x.NewText) && IsRangeEmpty(x.Range));
private bool ShouldShowDiagnosticContextMenu(IEnumerable <object> items) { return(_initialized && items.All(item => item is DiagnosticItem)); }
private static int CountNonAccents(string input, IEnumerable <Accent>?accents) { return(input.Count(c => accents?.All(a => a.Character != c) ?? true)); }
private bool ShouldShowAnalyzerContextMenu(IEnumerable <object> items) { return(items.All(item => item is AnalyzerItem)); }
public static void DoImport(object sender, DoWorkEventArgs e) { BackgroundWorker bw = sender as BackgroundWorker; // Parse list input parameters BackgroundWorkParameters param = (BackgroundWorkParameters)e.Argument; string _URL = param.Url; int categoryId = param.CategoryId; int portalId = param.PortalId; int vendorId = param.VendorId; string countryFilter = param.CountryFilter; string cityFilter = param.CityFilter; int? stepImport = param.StepImport; int feedId = param.FeedId; if (!File.Exists(_URL)) { // unzip file to temp folder if needed if (_URL.EndsWith(".zip")) { string zipFileName = String.Format("{0}\\{1}", Properties.Settings.Default.TempPath, "Hotels_Standard.zip"); // inside this function show progressBar for step: LoadFile if (File.Exists(zipFileName)) { File.Delete(zipFileName); } Common.SaveFileFromURL(_URL, zipFileName, 60, bw, e, log); // if user cancel during saving file or ERROR if (e.Cancel || (e.Result != null) && e.Result.ToString().Substring(0, 6).Equals("ERROR:")) { return; } // Set step for backgroundWorker Form1.activeStep = "Extract file.."; bw.ReportProgress(0); // start new step of background process using (ZipFile zip1 = ZipFile.Read(zipFileName)) { foreach (ZipEntry zipEntry in zip1) { zipEntry.Extract(Properties.Settings.Default.TempPath, ExtractExistingFileAction.OverwriteSilently); } } _URL = String.Format("{0}\\{1}", Properties.Settings.Default.TempPath, "Hotels_Standard.xml"); } } XmlSchemaSet schemas = new XmlSchemaSet(); schemas.Add("", "Hotels_Standard.xsd"); Form1.activeStep = "Validating input.."; bw.ReportProgress(0); // start new step of background process XDocument xDoc = XDocument.Load(_URL); bool errors = false; xDoc.Validate(schemas, (o, e2) => { e.Result = "ERROR:" + e2.Message; log.Error(e2.Message); errors = true; }); if (errors) { e.Cancel = true; return; } // show progress & catch Cancel if (bw.CancellationPending) { e.Cancel = true; return; } else if (bw.WorkerReportsProgress) { bw.ReportProgress(50); } // read hotels from XML // use XmlReader to avoid huge file size dependence var xmlProducts = from el in Common.StreamRootChildDoc(_URL, "hotel") select new ProductView { Country = (string)el.Element("hotel_country"), County = (string)el.Element("hotel_county"), City = (string)el.Element("hotel_city"), ProductNumber = (string)el.Element("hotel_ref"), Name = (string)el.Element("hotel_name"), Images = el.Element("images"), UnitCost = (string)el.Element("PricesFrom"), Description = (string)el.Element("hotel_description"), DescriptionHTML = (string)el.Element("alternate_description"), URL = (string)el.Element("hotel_link"), Star = (string)el.Element("hotel_star"), CustomerRating = (string)el.Element("customerrating"), Rooms = (string)el.Element("hotel_total_rooms"), Address = (string)el.Element("hotel_address"), PostCode = (string)el.Element("hotel_pcode"), CurrencyCode = (string)el.Element("CurrencyCode"), Lat = (string)el.Element("geo_code").Element("lat"), Long = (string)el.Element("geo_code").Element("long") }; if (!String.IsNullOrEmpty(countryFilter)) { xmlProducts = xmlProducts.Where(p => p.Country == countryFilter); } if (!String.IsNullOrEmpty(cityFilter)) { xmlProducts = xmlProducts.Where(p => p.City == cityFilter); } // show progress & catch Cancel if (bw.CancellationPending) { e.Cancel = true; return; } else if (bw.WorkerReportsProgress) { bw.ReportProgress(100); } Thread.Sleep(100); // a little bit slow working for visualisation Progress // Set step for backgroundWorker Form1.activeStep = "Import records.."; bw.ReportProgress(0); // start new step of background process int productCount = xmlProducts.Count(); try { int initialStep = 0; if (stepImport.HasValue) { initialStep = stepImport.Value; } using (SelectedHotelsEntities db = new SelectedHotelsEntities()) { int i = 0; foreach (ProductView product in xmlProducts) { if (i < initialStep) { i++; continue; } #if DEBUG Console.WriteLine(i + " - " + product.Name); // debug print #endif // create new product record Hotel hotel = db.Products.SingleOrDefault( p => p.ProductTypeId == (int)Enums.ProductTypeEnum.Hotels && p.Categories.Any(c => c.Id == categoryId) && p.Name == product.Name && p.Number == product.ProductNumber) as Hotel; if (hotel == null) { hotel = new Hotel(); hotel.ProductTypeId = (int)Enums.ProductTypeEnum.Hotels; hotel.Name = product.Name; hotel.Number = product.ProductNumber; if (!String.IsNullOrEmpty(product.UnitCost)) { hotel.UnitCost = Convert.ToDecimal(product.UnitCost); } hotel.Description = product.Description; hotel.URL = product.URL.Replace("[[PARTNERID]]", "2248").Trim(' '); hotel.Image = (string)product.Images.Element("url"); int star = 0; string strStar = new string(product.Star.TakeWhile(char.IsDigit).ToArray()); if (strStar.Length > 0) { star = int.Parse(strStar); hotel.Star = star; } if (!String.IsNullOrEmpty(product.CustomerRating)) { hotel.CustomerRating = int.Parse(product.CustomerRating); } if (!String.IsNullOrEmpty(product.Rooms)) { hotel.Rooms = int.Parse(product.Rooms); } if (!String.IsNullOrEmpty(product.Address)) { hotel.Address = product.Address; } if (!String.IsNullOrEmpty(product.PostCode)) { hotel.PostCode = product.PostCode; } if (!String.IsNullOrEmpty(product.CurrencyCode)) { hotel.CurrencyCode = product.CurrencyCode; } hotel.CreatedByUser = vendorId; hotel.CreatedDate = DateTime.Now; hotel.IsDeleted = false; hotel.HotelTypeId = (int)Enums.HotelTypeEnum.Hotels; hotel.FeedId = feedId; db.Products.Add(hotel); db.SaveChanges(); Common.SetLocation(product, db, hotel, log); Common.SetGeoNameId(product, db, hotel, log); Category category = db.Categories.Find(categoryId); if (category != null) { hotel.Categories.Add(category); } db.SaveChanges(); var imageURLs = product.Images.Elements("url").Where(xe => xe.Value.EndsWith(".jpg") || xe.Value.EndsWith(".png")).Select(xe => xe.Value); IEnumerable <string> imageURLList = imageURLs as IList <string> ?? imageURLs.ToList(); foreach (var imageURL in imageURLList) { ProductImage productImage = new ProductImage { URL = imageURL }; hotel.ProductImages.Add(productImage); } db.SaveChanges(); i++; Common.UpdateSteps(stepImport: i); } else { if (hotel.Location == null) { Common.SetLocation(product, db, hotel, log); } if (!hotel.GeoNameId.HasValue) { Common.SetGeoNameId(product, db, hotel, log); } decimal?unitCost = null; if (!String.IsNullOrEmpty(product.UnitCost)) { unitCost = decimal.Parse(product.UnitCost); } if (hotel.UnitCost != unitCost) { hotel.UnitCost = unitCost; } if (hotel.Description != product.Description) { hotel.Description = product.Description; } if (hotel.URL != product.URL.Replace("[[PARTNERID]]", "2248").Trim(' ')) { hotel.URL = product.URL.Replace("[[PARTNERID]]", "2248").Trim(' '); } if (hotel.Image != (string)product.Images.Element("url")) { hotel.Image = (string)product.Images.Element("url"); } int? star = null; string strStar = new string(product.Star.TakeWhile(char.IsDigit).ToArray()); if (strStar.Length > 0) { star = int.Parse(strStar); } if (hotel.Star != star) { hotel.Star = star; } int?customerRating = null; if (!String.IsNullOrEmpty(product.CustomerRating)) { customerRating = int.Parse(product.CustomerRating); } if (hotel.CustomerRating != customerRating) { hotel.CustomerRating = customerRating; } int?rooms = null; if (!String.IsNullOrEmpty(product.Rooms)) { rooms = int.Parse(product.Rooms); } if (hotel.Rooms != rooms) { hotel.Rooms = rooms; } if (hotel.Address != product.Address) { hotel.Address = product.Address; } if (hotel.PostCode != product.PostCode) { hotel.PostCode = product.PostCode; } if (hotel.CurrencyCode != product.CurrencyCode) { hotel.CurrencyCode = product.CurrencyCode; } db.SaveChanges(); var imageURLs = product.Images.Elements("url").Where(xe => xe.Value.EndsWith(".jpg") || xe.Value.EndsWith(".png")).Select(xe => xe.Value); IEnumerable <string> imageURLList = imageURLs as IList <string> ?? imageURLs.ToList(); foreach (var imageURL in imageURLList) { ProductImage productImage = hotel.ProductImages.SingleOrDefault(pi => pi.URL == imageURL); if (productImage == null) { productImage = new ProductImage { URL = imageURL }; hotel.ProductImages.Add(productImage); } } db.SaveChanges(); var productImagesToRemove = db.ProductImages.Where(pi => pi.ProductId == hotel.Id && imageURLList.All(xe => xe != pi.URL)); if (productImagesToRemove.Any()) { db.ProductImages.RemoveRange(productImagesToRemove); } db.SaveChanges(); i++; Common.UpdateSteps(stepImport: i); } if (bw.CancellationPending) { e.Cancel = true; goto Cancelled; } else if (bw.WorkerReportsProgress && i % 100 == 0) { bw.ReportProgress((int)(100 * i / productCount)); } } } if (!e.Cancel) { Common.UpdateSteps(); } Cancelled: ; } catch (DbEntityValidationException exception) { foreach (var eve in exception.EntityValidationErrors) { log.Error(String.Format("Entity of type \"{0}\" in state \"{1}\" has the following validation errors:", eve.Entry.Entity.GetType().Name, eve.Entry.State), exception); foreach (var ve in eve.ValidationErrors) { log.Error(String.Format("- Property: \"{0}\", Error: \"{1}\"", ve.PropertyName, ve.ErrorMessage), exception); } } throw; } catch (Exception ex) { e.Result = "ERROR:" + ex.Message; log.Error("Error error logging", ex); } }
public static bool NotIn(this string str, IEnumerable <string> options) { return(options.All(opt => opt.ToLower() != str.ToLower())); }
public static bool IsHex(IEnumerable <char> chars) => chars.All(c => ((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F')));
/// <summary> /// Creates a new DAQmx task and adds channels to it /// </summary> /// <param name="nodes">Graph nodes of type MetricAnalogOutput</param> /// <exception cref="InvalidCastException">At least one element in <paramref name="nodes"/> not of type MetricAnalogOutput</exception> /// <exception cref="InvalidOperationException">At least one element in <paramref name="nodes"/> not connected to the instance's specified device</exception> /// <exception cref="NidaqException">Task or channel could not be created</exception> public void CreateTask(IEnumerable <INidaqMetric> nodes) { if (!nodes.All(n => n is MetricAnalogOutput)) { throw new InvalidCastException("all passed nodes must be of type MetricAnalogOutput"); } if (!nodes.All(n => n.Channel.Device == Device)) { throw new InvalidOperationException("not all passed nodes are connected to device " + Device.Name); } ClockRate = ((MetricAnalogOutput)nodes.First()).Samplerate; if (!nodes.All(n => ((MetricAnalogOutput)n).Samplerate == ClockRate)) { ClockRate = 0; SamplesPerChannel = 0; throw new InvalidOperationException("NIDAQ: not all analog output nodes in graph have the same samplerate"); } foreach (var n in nodes.OfType <MetricAnalogOutput>()) { n.Samplerate = ClockRate; } var nidaqBufferSizePerChannel = (int)(BufferLengthMs * (long)ClockRate / 1000); var localBufferSizePerChannel = (int)(2 * (BufferLengthMs + PrebufferLengthMs) * (long)ClockRate / 1000); SamplesPerChannel = nidaqBufferSizePerChannel; // ------------------------------ // Configure DAQMX Task _task = new NationalInstruments.DAQmx.Task(); foreach (var output in nodes.OfType <MetricAnalogOutput>()) { output.ChannelNumber = _nodes.Count; _task.AOChannels.CreateVoltageChannel( output.Channel.Path, string.Empty, output.VMin, output.VMax, NationalInstruments.DAQmx.AOVoltageUnits.Volts ); _nodes.Add(output); } _task.Timing.ConfigureSampleClock( "", ClockRate, NationalInstruments.DAQmx.SampleClockActiveEdge.Rising, NationalInstruments.DAQmx.SampleQuantityMode.ContinuousSamples, SamplesPerChannel ); try { _task.Stream.ConfigureOutputBuffer(SamplesPerChannel); } catch (NationalInstruments.DAQmx.DaqException e) { throw new NidaqException(e.Error); } _task.Stream.Timeout = WriteTimeoutMs; _task.Stream.WriteRegenerationMode = NationalInstruments.DAQmx.WriteRegenerationMode.DoNotAllowRegeneration; try { _task.Control(NationalInstruments.DAQmx.TaskAction.Verify); } catch (NationalInstruments.DAQmx.DaqException e) { throw new NidaqException(e.Error); } _task.Stream.Buffer.OutputBufferSize = SamplesPerChannel; _writer = new NationalInstruments.DAQmx.AnalogMultiChannelWriter(_task.Stream); TaskHandle = _task.GetHashCode(); _usableData = new double[_nodes.Count, SamplesPerChannel]; _bufferData = new double[_nodes.Count, localBufferSizePerChannel]; _channelCount = new int[_nodes.Count]; State = SessionTaskState.Stopped; _first = true; }
private static bool allValuesEqual(IEnumerable <Card> cards) { var f = cards.First(); return(cards.All(c => c.Value.Equals(f.Value, StringComparison.OrdinalIgnoreCase))); }
public void VerifyValidYear() { var hasvalidYears = Rows.All(x => x.Year > 1950 && x.Year < DateTime.Now.Year + 1); hasvalidYears.Should().BeTrue(); }
/////////////////////////////////////////////////////////////////// #region Private Methods private static bool IsConditionMet(bool condition, IEnumerable <bool> values) { return(values?.All(m => m == condition) ?? false); }
private static bool allSuitsEqual(IEnumerable <Card> cards) { var f = cards.First(); return(cards.All(c => c.Suit == f.Suit)); }
private bool IsAuthorizedToGet <TExecutionUser>(IEnumerable <object> entities, TExecutionUser executionUser = null, object grandparent = null, object parent = null) where TExecutionUser : class { return(executionUser == null || (entities?.All(entity => IsAuthorizedToGetSingle(entity, executionUser, grandparent, parent)) ?? true)); }
public static bool None <T>(this IEnumerable <T> enumerable, Func <T, bool> predicate) { // none means: tell me if a certain assumption is false for all elements return(enumerable.All(t => !predicate(t))); }