// dstore public static void CreateDataStore(DataStore dstore) { // grab current line contents var dstoreEntries = dstore.DataLines.Select(x => x.Contents).ToList(); // read current dstore type if any DataStoreType exstDStoreType = dstore.DataFormatter.ReadDataStoreType(dstoreEntries); // check if existing data store is defined and matches the provided type if (exstDStoreType != null && !exstDStoreType.Equals(dstore.DataStoreType)) { throw new Exception( string.Format("Datastore type does not match existing \"{0}\"", exstDStoreType) ); } // if no existing dstore type is found, create based on input dstore type if (exstDStoreType is null) { // if file is not empty, throw an exception if (dstore.DataLines.Count > 0) { throw new Exception("Datastore is not configured as a flat database and is not empty."); } // if empty // ask the formatter to build the entry and submit a change request var ecReq = dstore.DataFormatter.BuildDataStoreEntry(dstoreEntries, dstore.DataStoreType); // submit dstore and entry change request for processing ProcessChangeRequest(dstore, ecReq); } }
public void UseBackupWhenAppropriate(DataStoreType appSetting, bool expectedOutcome) { TestAppSettings.SetDataStoreType(appSetting); var payment = new PaymentService(); Assert.AreEqual(expectedOutcome, payment.GetDataStore() is BackupAccountDataStore); }
public void Configuration_Page_Shows_All_Settings() { // Arrange LoginAsAdmin(); // Act Driver.FindElement(By.CssSelector("a[href='/settings']")).Click(); // Assert Assert.That(Driver.ElementValue("#SiteName"), Is.EqualTo("Acceptance Tests")); Assert.That(Driver.ElementValue("#SiteUrl"), Is.EqualTo("http://*****:*****@"~/App_Data/Attachments")); Assert.That(Driver.ElementValue("#AllowedFileTypes"), Is.EqualTo("jpg,png,gif,zip,xml,pdf")); Assert.False(Driver.IsCheckboxChecked("UseWindowsAuth")); Assert.True(Driver.IsCheckboxChecked("AllowUserSignup")); Assert.False(Driver.IsCheckboxChecked("IsRecaptchaEnabled")); Assert.False(Driver.IsCheckboxChecked("UseObjectCache")); Assert.False(Driver.IsCheckboxChecked("UseBrowserCache")); Assert.That(Driver.FindElements(By.CssSelector("#DataStoreTypeName option")).Count, Is.EqualTo(DataStoreType.AllTypes.Count())); SelectElement element = new SelectElement(Driver.FindElement(By.CssSelector("#DataStoreTypeName"))); Assert.That(element.SelectedOption.GetAttribute("value"), Is.EqualTo(DataStoreType.ByName("SqlServer2012").Name)); Assert.That(Driver.SelectedIndex("#MarkupType"), Is.EqualTo(0)); Assert.That(Driver.SelectedIndex("#Theme"), Is.EqualTo(3)); Assert.False(Driver.IsCheckboxChecked("OverwriteExistingFiles")); Assert.That(Driver.ElementValue("#HeadContent"), Is.EqualTo("")); Assert.That(Driver.ElementValue("#MenuMarkup"), Is.EqualTo("* %mainpage%\r\n* %categories%\r\n* %allpages%\r\n* %newpage%\r\n* %managefiles%\r\n* %sitesettings%\r\n\r\n")); }
public DataStoreType ReadDataStoreType(List <string> dstoreEntries) { DataStoreType dstoreType = null; var dstoreFinder = buildMdataRegex(mdataDStore, "dstoretype"); var dstoreSourceFinder = buildMdataRegex(mdataDStoreSource, "dstorefile"); var dstoreVersionFinder = buildMdataRegex(mdataDStoreVersion, "dstoreversion"); var dstoreEncodingFinder = buildMdataRegex(mdataDStoreEncoding, "dstoreencoding"); foreach (string dsEntry in dstoreEntries) { var match = dstoreFinder.Match(dsEntry); if (match.Success) { var dbinfo = decodeValue(match.Groups["dstoretype"].Value); var sourceMatch = dstoreSourceFinder.Match(dsEntry); var versionMatch = dstoreVersionFinder.Match(dsEntry); var encodingMatch = dstoreEncodingFinder.Match(dsEntry); dstoreType = new DataStoreType( dsource: decodeValue(sourceMatch.Groups["dstorefile"].Value), dsourceVersion: new Version(decodeValue(versionMatch.Groups["dstoreversion"].Value)), dsourceEncoding: Encoding.GetEncoding(decodeValue(encodingMatch.Groups["dstoreencoding"].Value)) ); break; } } return(dstoreType); }
internal void FinalizeInstall(SettingsViewModel model) { // The name as a string is passed through each step, so parse it DataStoreType dataStoreType = DataStoreType.ByName(model.DataStoreTypeName); model.DataStoreTypeName = dataStoreType.Name; // Update all repository references for the dependencies of this class // (changing the For() in StructureMap won't do this as the references have already been created). _repository = RepositoryManager.ChangeRepository(dataStoreType, model.ConnectionString, model.UseObjectCache); UserService.UpdateRepository(_repository); _settingsService.UpdateRepository(_repository); _searchService.UpdateRepository(_repository); // Default these two properties for installations model.IgnoreSearchIndexErrors = true; model.IsPublicSite = true; // Update the web.config first, so all connections can be referenced. _configReaderWriter.Save(model); // Create the roadkill schema and save the configuration settings _settingsService.CreateTables(model); _settingsService.SaveSiteSettings(model); // Add a user if we're not using AD. if (!model.UseWindowsAuth) { UserService.AddUser(model.AdminEmail, "admin", model.AdminPassword, true, false); } // Create a blank search index _searchService.CreateIndex(); }
public void AddObjectDataStore(JObject value, DataStoreType dataStoreType) { foreach (var val in value) { this.UpdateValue(dataStoreType, this.CurrentRoute, val.Key, val.Value); } }
public void Startup(DataStoreType dataStoreType, string connectionString, bool enableCache) { if (!string.IsNullOrEmpty(connectionString)) { LightSpeedContext context = new LightSpeedContext(); context.ConnectionString = connectionString; context.DataProvider = dataStoreType.LightSpeedDbType; context.IdentityMethod = IdentityMethod.GuidComb; context.CascadeDeletes = true; context.VerboseLogging = true; context.Logger = new DatabaseLogger(); if (enableCache) context.Cache = new CacheBroker(new DefaultCache()); ObjectFactory.Configure(x => { x.For<LightSpeedContext>().Singleton().Use(context); x.For<IUnitOfWork>().HybridHttpOrThreadLocalScoped().Use(ctx => ctx.GetInstance<LightSpeedContext>().CreateUnitOfWork()); }); } else { Log.Warn("LightSpeedRepository.Startup skipped as no connection string was provided"); } }
public static void GatherStorePattern(string reportName, DataStoreType type) // 采集存储模式 { GatherReport report = new GatherReport(); GatherTable tab = report.GetReportTable(reportName); tab.采集模式(type); }
public virtual void Install(DataStoreType dataStoreType, string connectionString, bool enableCache) { Installed = true; InstalledDataStoreType = dataStoreType; InstalledConnectionString = connectionString; InstalledEnableCache = enableCache; }
private JToken GetLastValueFromDataStore(string key, DataStoreType dataStoreType = DataStoreType.Any) { List <DataStoreItem> itemsList = null; JToken itemToReturn = null; if (dataStoreType == DataStoreType.Private || dataStoreType == DataStoreType.Any) { var values = GetValueAndRoutesFromDataStore(this.PrivateDataStore, key, DataStoreType.Private); if (values.Any()) { itemsList = values; } } if (dataStoreType == DataStoreType.Public || dataStoreType == DataStoreType.Any) { var values = GetValueAndRoutesFromDataStore(this.PublicDataStore, key, DataStoreType.Private); if (values.Any()) { itemsList = values; } } if (itemsList != null) { itemToReturn = itemsList.Any(p => p.Route.ToLowerInvariant() == "requestparameters") ? itemsList.Single(p => p.Route.ToLowerInvariant() == "requestparameters").Value : itemsList.Last().Value; } return(itemToReturn); }
public void UpdateValue(DataStoreType dataStoreType, string route, string key, JToken value) { bool foundInPrivate = false; bool foundInPublic = false; if (dataStoreType == DataStoreType.Private || dataStoreType == DataStoreType.Any) { foundInPrivate = UpdateItemIntoDataStore(this.PrivateDataStore, route, key, value); } if (dataStoreType == DataStoreType.Public || dataStoreType == DataStoreType.Any) { foundInPublic = UpdateItemIntoDataStore(this.PublicDataStore, route, key, value); } if (!foundInPublic && !foundInPrivate) { if (dataStoreType == DataStoreType.Private || dataStoreType == DataStoreType.Any) { AddModifyItemToDataStore(this.PrivateDataStore, route, key, value); } if (dataStoreType == DataStoreType.Public) { AddModifyItemToDataStore(this.PublicDataStore, route, key, value); } } }
public void LoadGatherTable(GatherInfo info, GatherTimer time, IGatherItem IItem, IGatherDB db, IThreadAction _action) { this._action = _action; this._db = db; this._info = info; this.tb = db.GetDataTable(); this.临时缓存 = this.tb.Clone(); this.临时缓存.TableName = info.reportName; this.time = time; GatherItem item = null; row = new GatherRow(); int count = this.tb.Columns.Count; GatherField field = null; for (int i = 0; i < count; i++) { field = info.GetFiled(this.tb.Columns[i].ColumnName); if (field == null) { continue; } if (field._SourceType != 数据来源类型.未知) { item = new GatherItem(field, IItem.GetComputerItem(field.DataNo)); } else { item = new GatherItem(field, IItem.GetIValue(field.DataNo)); } this.row.AddItem(item); } storeType = DataStoreType.SynDB; // 默认采集模式是同步进行 }
public List <Dictionary <string, object> > ReadRecordsData(List <string> dstoreEntries, DataStoreType dstoreType, DatabaseDefinition dbDef, TableDefinition tableDef) { var recordList = new List <Dictionary <string, object> >(); // find table range var tableRange = extractTableRange(dstoreType.TypeName, dstoreEntries, dbDef, tableDef); // skip the table def line foreach (string entryLine in dstoreEntries.GetRange(tableRange.First + 1, tableRange.Count - 1)) { string cleanedDLine = entryLine; if (tableDef.IsHidden) { cleanedDLine = cleanedDLine.Replace(medataLineStart + mdataRecordSeparator, ""); } var fieldValues = cleanedDLine.Split(new string[] { tableDef.FieldDelimiter }, StringSplitOptions.None); var fieldValuesDict = new Dictionary <string, object>(); int fieldIndex = 0; foreach (var field in tableDef.Fields) { fieldValuesDict.Add(field.Name, decodeFieldValue(fieldValueString: fieldValues[fieldIndex], fieldType: field.FieldType)); fieldIndex++; } recordList.Add(fieldValuesDict); } return(recordList); }
internal GeneralPurpose(object container, IComparer <TKey> comparer, string name, DataStoreType dataStoreType, ISortedDictionaryOnDisk dataStore, bool isDataInKeySegment) : base( container, comparer, name, dataStoreType, dataStore, isDataInKeySegment) { }
/// <summary> /// Tests the database connection, changing the current registered repository. /// </summary> /// <param name="connectionString">The connection string.</param> /// <returns>Any error messages or an empty string if no errors occurred.</returns> public static string TestDbConnection(string connectionString, string databaseType) { try { DataStoreType dataStoreType = DataStoreType.ByName(databaseType); if (dataStoreType == null) { dataStoreType = DataStoreType.ByName("SQLServer2005"); } IRepository repository = ChangeRepository(dataStoreType, connectionString, false); repository.TestConnection(dataStoreType, connectionString); return(""); } catch (Exception e) { return(e.ToString()); } finally { // Restore to their previous state ApplicationSettings appSettings = ObjectFactory.GetInstance <ApplicationSettings>(); IRepository repository = ChangeRepository(appSettings.DataStoreType, appSettings.ConnectionString, false); } }
public void Startup(DataStoreType dataStoreType, string connectionString, bool enableCache) { if (!string.IsNullOrEmpty(connectionString)) { LightSpeedContext context = new LightSpeedContext(); context.ConnectionString = connectionString; context.DataProvider = dataStoreType.LightSpeedDbType; context.IdentityMethod = IdentityMethod.GuidComb; context.CascadeDeletes = true; if (_applicationSettings.IsLoggingEnabled) { context.VerboseLogging = true; context.Logger = new DatabaseLogger(); } if (enableCache) { context.Cache = new CacheBroker(new DefaultCache()); } ObjectFactory.Configure(x => { x.For <LightSpeedContext>().Singleton().Use(context); x.For <IUnitOfWork>().HybridHttpOrThreadLocalScoped().Use(ctx => ctx.GetInstance <LightSpeedContext>().CreateUnitOfWork()); }); } else { Log.Warn("LightSpeedRepository.Startup skipped as no connection string was provided"); } }
public void AddObjectDataStore(string route, JObject value, DataStoreType dataStoreType) { foreach (var val in value) { this.UpdateValue(dataStoreType, route, val.Key, val.Value); } }
public DataStore FindDataStore(DataStoreType tag) { DataStore dataStoreResult = null; dataStoreDict.TryGetValue(tag, out dataStoreResult); return(dataStoreResult); }
internal static string ToSerializedValue(this DataStoreType value) { switch (value) { case DataStoreType.AzureBlob: return("AzureBlob"); case DataStoreType.AzureFile: return("AzureFile"); case DataStoreType.AzureDataLake: return("AzureDataLake"); case DataStoreType.AzureSqlDatabase: return("AzureSqlDatabase"); case DataStoreType.AzurePostgreSql: return("AzurePostgreSql"); case DataStoreType.DBFS: return("DBFS"); case DataStoreType.AzureDataLakeGen2: return("AzureDataLakeGen2"); case DataStoreType.GlusterFs: return("GlusterFs"); } return(null); }
public DataStore(DataStoreType type, string key, string data, string username, string userToken) { Type = type; Key = key; Data = data; Username = username; UserToken = userToken; }
public StageTableCfg(string dir, string table, bool isNativeStore = true, string tsCol = null, DataStoreType storeType = DataStoreType.Db) { Dir = dir; Table = table; IsNativeStore = isNativeStore; StoreType = storeType; TsCol = tsCol ?? (isNativeStore ? "Updated" : null); }
public ItemDetailViewModel(DataStoreType dataStoreType, Item item = null) { Title = item?.Name; DataStoreType_ = dataStoreType; Item = item; DisposalDataStore = new MockDisposedDataStore(); ShoppingDataStore = new MockShoppingDataStore(); }
public void ByName_Should_Throw_DatabaseException_If_DataStoreType_Not_Found() { // Arrange IEnumerable <DataStoreType> dataStoreTypes = DataStoreType.AllTypes; // Act + Assert DataStoreType datastoreType = DataStoreType.ByName("thunderbird"); }
/// <summary> /// Saves the configuration settings. This will save a subset of the <see cref="SettingsViewModel" /> based on /// the values that match those found in the <see cref="RoadkillSection" /> /// </summary> /// <param name="settings">The application settings.</param> /// <exception cref="InstallerException">An exception occurred while updating the settings to the web.config</exception> public override void Save(SettingsViewModel settings) { try { if (settings.UseWindowsAuth) { WriteConfigForWindowsAuth(); } else { WriteConfigForFormsAuth(); } // Create a "Roadkill" connection string, or use the existing one if it exists. ConnectionStringSettings roadkillConnection = new ConnectionStringSettings("Roadkill", settings.ConnectionString); if (_config.ConnectionStrings.ConnectionStrings["Roadkill"] == null) { _config.ConnectionStrings.ConnectionStrings.Add(roadkillConnection); } else { _config.ConnectionStrings.ConnectionStrings["Roadkill"].ConnectionString = settings.ConnectionString; } // The roadkill section DataStoreType dataStoreType = DataStoreType.ByName(settings.DataStoreTypeName); RoadkillSection section = _config.GetSection("roadkill") as RoadkillSection; section.AdminRoleName = settings.AdminRoleName; section.AttachmentsFolder = settings.AttachmentsFolder; section.AzureContainer = settings.AzureContainer; section.UseObjectCache = settings.UseObjectCache; section.UseBrowserCache = settings.UseBrowserCache; section.ConnectionStringName = "Roadkill"; section.DataStoreType = dataStoreType.Name; section.EditorRoleName = settings.EditorRoleName; section.LdapConnectionString = settings.LdapConnectionString; section.LdapUsername = settings.LdapUsername; section.LdapPassword = settings.LdapPassword; section.RepositoryType = dataStoreType.CustomRepositoryType; section.UseWindowsAuthentication = settings.UseWindowsAuth; section.Version = ApplicationSettings.FileVersion.ToString(); section.UseGoogleAnalytics = settings.UseGoogleAnalytics; section.GAName = settings.GAName; section.GANumber = settings.GANumber; // For first time installs: these need to be explicit as the DefaultValue="" in the attribute doesn't determine the value when saving. section.IsPublicSite = settings.IsPublicSite; section.IgnoreSearchIndexErrors = settings.IgnoreSearchIndexErrors; section.Installed = true; _config.Save(ConfigurationSaveMode.Minimal); } catch (ConfigurationErrorsException ex) { throw new InstallerException(ex, "An exception occurred while updating the settings to the web.config"); } }
/// <summary> /// Gets the current application settings, which is usually cached settings from the <see cref="Load" /> method. /// </summary> /// <returns> /// A new <see cref="ApplicationSettings" /> instance /// </returns> public override ApplicationSettings GetApplicationSettings() { ApplicationSettings appSettings = new ApplicationSettings(); appSettings.AdminRoleName = _section.AdminRoleName; appSettings.AttachmentsFolder = _section.AttachmentsFolder; appSettings.AttachmentsRoutePath = _section.AttachmentsRoutePath; appSettings.AzureConnectionString = _section.AzureConnectionString; appSettings.AzureContainer = _section.AzureContainer; appSettings.ConnectionStringName = _section.ConnectionStringName; appSettings.ConnectionString = _config.ConnectionStrings.ConnectionStrings[_section.ConnectionStringName].ConnectionString; if (string.IsNullOrEmpty(appSettings.ConnectionString)) { appSettings.ConnectionString = ConfigurationManager.ConnectionStrings[_section.ConnectionStringName].ConnectionString; } if (string.IsNullOrEmpty(appSettings.ConnectionString)) { Log.Warn("ConnectionString property is null/empty."); } // Ignore the legacy useCache and cacheText section keys, as the behaviour has changed. appSettings.UseObjectCache = _section.UseObjectCache; appSettings.UseBrowserCache = _section.UseBrowserCache; // Look for the legacy database type key string dataStoreType = _section.DataStoreType; if (string.IsNullOrEmpty(dataStoreType) && !string.IsNullOrEmpty(_section.DatabaseType)) { dataStoreType = _section.DatabaseType; } appSettings.LoggingTypes = _section.Logging; appSettings.LogErrorsOnly = _section.LogErrorsOnly; appSettings.DataStoreType = DataStoreType.ByName(dataStoreType); appSettings.ConnectionStringName = _section.ConnectionStringName; appSettings.EditorRoleName = _section.EditorRoleName; appSettings.IgnoreSearchIndexErrors = _section.IgnoreSearchIndexErrors; appSettings.IsPublicSite = _section.IsPublicSite; appSettings.Installed = _section.Installed; appSettings.LdapConnectionString = _section.LdapConnectionString; appSettings.LdapUsername = _section.LdapUsername; appSettings.LdapPassword = _section.LdapPassword; appSettings.RepositoryType = _section.RepositoryType; appSettings.UseAzureFileStorage = _section.UseAzureFileStorage; appSettings.UseHtmlWhiteList = _section.UseHtmlWhiteList; appSettings.UserServiceType = _section.UserServiceType; appSettings.UseWindowsAuthentication = _section.UseWindowsAuthentication; appSettings.UpgradeRequired = UpgradeChecker.IsUpgradeRequired(_section.Version); appSettings.UseGoogleAnalytics = _section.UseGoogleAnalytics; appSettings.GAName = _section.GAName; appSettings.GANumber = _section.GANumber; return(appSettings); }
/// <summary> /// /// </summary> /// <param name="dataStoreType"></param> /// <param name="connectionString"></param> /// <exception cref="MongoConnectionException">Can't connect to the MongoDB server (but it's a valid connection string)</exception> public void TestConnection(DataStoreType dataStoreType, string connectionString) { string databaseName = MongoUrl.Create(connectionString).DatabaseName; MongoClient client = new MongoClient(connectionString); MongoServer server = client.GetServer(); MongoDatabase database = server.GetDatabase(databaseName); database.GetCollectionNames(); }
public override void Save(SettingsViewModel settings) { Saved = true; // The bare minimum needed to test the installer ApplicationSettings.ConnectionString = settings.ConnectionString; ApplicationSettings.DataStoreType = DataStoreType.ByName(settings.DataStoreTypeName); ApplicationSettings.UseBrowserCache = settings.UseBrowserCache; ApplicationSettings.UseObjectCache = settings.UseObjectCache; }
public string GetValueAtIndex(string key, string index, DataStoreType dataStoreType = DataStoreType.Any) { int i = 0; if (this.KeyExists(index)) { i = int.Parse(this.GetValue(index)); } return(this.GetAllValues(key)[i]); }
public void ByName_Should_Find_DataStoreType_And_Be_Case_Insensitive() { // Arrange IEnumerable <DataStoreType> dataStoreTypes = DataStoreType.AllTypes; // Act DataStoreType datastoreType = DataStoreType.ByName("mOngoDB"); // Assert Assert.That(datastoreType.Name, Is.EqualTo("MongoDB")); }
public bool RouteAndKeyExists(string route, string key, DataStoreType dataStoreType = DataStoreType.Any) { var listOfKeys = this.GetValueAndRoutesFromDataStore(dataStoreType, key).ToList(); if (listOfKeys.Any()) { return(listOfKeys.Any(p => p.Route.ToLowerInvariant().Equals(route.ToLowerInvariant()))); } return(false); }
public async Task <int[]> MakeAndSum(int size, int shift, DataStoreType dataStoreType) { Log.Information("MakeAndSum Started - {Size} - Enum Parameter {DataStoreType}", size, dataStoreType); var things = (0 + shift).RangeTo(size + shift).Select(i => new Thing { Number = i }); var res = await things.Process(Ctx, b => CountThings(b), new() { MaxParallel = 2 }); Log.Information("MakeAndSum Complete {Batches}", res.Count); return(res.Select(r => r.OutState).ToArray()); }
public void TestConnection(DataStoreType dataStoreType, string connectionString) { LightSpeedContext context = ObjectFactory.GetInstance<LightSpeedContext>(); if (context == null) throw new InvalidOperationException("Repository.Test failed - LightSpeedContext was null from the ObjectFactory"); using (IDbConnection connection = context.DataProviderObjectFactory.CreateConnection()) { connection.ConnectionString = connectionString; connection.Open(); } }
public void LoadGatherTable(GatherInfo info, GatherTimer time, IGatherItem IItem,IGatherDB db,IThreadAction _action) { this._action = _action; this._db = db; this._info = info; this.tb = db.GetDataTable(); this.临时缓存 = this.tb.Clone(); this.临时缓存.TableName = info.reportName; this.time = time; GatherItem item = null; row = new GatherRow(); int count = this.tb.Columns.Count; GatherField field = null; for (int i = 0; i < count; i++) { field = info.GetFiled(this.tb.Columns[i].ColumnName); if (field == null) { continue; } if (field._SourceType != 数据来源类型.未知) item = new GatherItem(field, IItem.GetComputerItem(field.DataNo)); else item = new GatherItem(field, IItem.GetIValue(field.DataNo)); this.row.AddItem(item); } storeType = DataStoreType.SynDB; // 默认采集模式是同步进行 }
public void Install(DataStoreType dataStoreType, string connectionString, bool enableCache) { LightSpeedContext context = ObjectFactory.GetInstance<LightSpeedContext>(); if (context == null) throw new InvalidOperationException("Repository.Install failed - LightSpeedContext was null from the ObjectFactory"); using (IDbConnection connection = context.DataProviderObjectFactory.CreateConnection()) { connection.ConnectionString = connectionString; connection.Open(); IDbCommand command = context.DataProviderObjectFactory.CreateCommand(); command.Connection = connection; dataStoreType.Schema.Drop(command); dataStoreType.Schema.Create(command); } }
// 采集存储模式 public void GatherStorePattern(string reportName,DataStoreType type) { GatherFace.GatherStorePattern(reportName,type); }
public void 采集模式(DataStoreType storeType) { this.storeType = storeType; if (storeType == DataStoreType.LastDB) { actionData = AddArr; } else { actionData = AddArrToDB; } }
// 采集存储模式 public static void GatherStorePattern(string reportName,DataStoreType type) { GatherReport report = new GatherReport(); GatherTable tab = report.GetReportTable(reportName); tab.采集模式(type); }