public void Create() { Delete(); _targetDatabase.Collation = "Latin1_General_CI_AI"; var fileGroup = new FileGroup(_targetDatabase, "PRIMARY"); _targetDatabase.FileGroups.Add(fileGroup); var dataFile = new DataFile(fileGroup, _targetSettings.DatabaseName, _targetSettings.DataFilePath) { Growth = 10, GrowthType = FileGrowthType.Percent }; fileGroup.Files.Add(dataFile); var logFile = new LogFile(_targetDatabase, string.Format("{0}_log", _targetSettings.DatabaseName), _targetSettings.LogFilePath) { Growth = 10, GrowthType = FileGrowthType.Percent }; _targetDatabase.LogFiles.Add(logFile); _targetDatabase.Collation = _sourceDatabase.Collation; Logger.WriteLine("Creating target database {0}", _targetSettings.DatabaseName); _targetDatabase.DatabaseOptions.Trustworthy = true; _targetDatabase.Create(); }
public async Task <MessageViewModel> UpdateName([FromBody] RenameGroupParams renameGroupParams) { MessageViewModel msg = RenameGroupParamsValidator.Validate(renameGroupParams); if (msg.Code != MessageCode.Success) { return(msg); } FileGroup group = await fileGroupBusiness.Get(this.CurrentAuthShopId(), renameGroupParams.GroupId); if (group == null) { return new MessageViewModel { Code = MessageCode.Fail, Message = "分组不存在" } } ; group.Name = renameGroupParams.GroupName; fileGroupBusiness.Update(group); return(new MessageViewModel { Code = MessageCode.Success, Message = "重命名成功" }); }
/// <summary> /// Return a list of file paths from the corresponding group in the target library /// </summary> public static IEnumerable <PathAndPropertiesTuple> GetFilePathAndProperties( this FileGroup fileGroup, LockFileTargetLibrary package) { switch (fileGroup) { case FileGroup.CompileTimeAssembly: return(SelectPath(package.CompileTimeAssemblies)); case FileGroup.RuntimeAssembly: return(SelectPath(package.RuntimeAssemblies)); case FileGroup.ContentFile: return(SelectPath(package.ContentFiles)); case FileGroup.NativeLibrary: return(SelectPath(package.NativeLibraries)); case FileGroup.ResourceAssembly: return(SelectPath(package.ResourceAssemblies)); case FileGroup.RuntimeTarget: return(SelectPath(package.RuntimeTargets)); case FileGroup.FrameworkAssembly: return(package.FrameworkAssemblies.Select(c => Tuple.Create(c, _emptyProperties))); default: throw new ArgumentOutOfRangeException(nameof(fileGroup)); } }
private static string replacePlaceholders(string text, FileGroup fileGroup) { return(text .Replace(PlaceholderFileGroupName, makeFolderNameCompatible(fileGroup.Name)) .Replace(PlaceholderFileGroupNumber, Math.Abs(fileGroup.UniqueID.GetHashCode()).ToString(CultureInfo.InvariantCulture))); }
static void Main(string[] args) { //Program Start //string choice; //Console.WriteLine("Choose Your Option:\n1:Company To Removeable Disk\n2:Home To Removeable Disk"); //Console.WriteLine("3:Removeable Disk To Company\n4:Removeable Disk To Home\n"); //choice = Console.ReadKey().KeyChar.ToString(); //switch (choice) //{ // case "1": // Console.WriteLine("Now Start Company To Removeable Disk\n"); // break; // //case "2": // // Console.WriteLine("Press 2"); // // break; // //case "3": // // Console.WriteLine("Press 3"); // // break; // //case "4": // // Console.WriteLine("Press 4"); // // break; // //default: // // Console.WriteLine("You Should Make Right Choice!"); // // return; //} //Start Logic FileGroup home = new FileGroup(EStations.Home.ToString()); home.ReadFromXML(EStations.Home); home.Show(); Console.ReadKey(); }
public IOutput Create() { var group = new FileGroup("Ids"); var sb = new StringBuilder(); sb.Al($"namespace {_module.Namespace}.Core.Ids"); sb.Al("{"); sb.I(1).Al("public interface IIdGenerator"); sb.I(1).Al("{"); sb.I(2).Al("Guid New();"); sb.I(1).Al("}"); sb.Al("}"); group.AddFile(new File("IIdGenerator.cs", sb.ToString(), canOverwrite: true)); sb.Clear(); sb.Al($"namespace {_module.Namespace}.Core.Ids"); sb.Al("{"); sb.I(1).Al("public class NulloIdGenerator : IIdGenerator"); sb.I(1).Al("{"); sb.I(2).Al("public Guid New() => Guid.NewGuid();"); sb.I(1).Al("}"); sb.Al("}"); group.AddFile(new File("NulloIdGenerator.cs", sb.ToString(), canOverwrite: true)); return(group); }
public Filetypevaliator(FileGroup filetype) { if (filetype == FileGroup.Image) { validtypes = new string[] { "image/jpeg", "image/png", "image/gif" }; } }
public void Fill(Database database, string connectionString) { try { if (database.Options.Ignore.FilterTableFileGroup) { using (SqlConnection conn = new SqlConnection(connectionString)) { using (SqlCommand command = new SqlCommand(GetSQL(), conn)) { conn.Open(); using (SqlDataReader reader = command.ExecuteReader()) { while (reader.Read()) { FileGroup item = new FileGroup(database); item.Id = (int)reader["ID"]; item.Name = reader["name"].ToString(); item.Owner = ""; item.IsDefaultFileGroup = (bool)reader["is_default"]; item.IsReadOnly = (bool)reader["is_read_only"]; item.IsFileStream = reader["type"].Equals("FD"); FillFiles(item, connectionString); database.FileGroups.Add(item); } } } } } } catch { throw; } }
private List <MeterDataSet> LoadMeterDataSets(AdoDataConnection connection, FileGroup fileGroup) { List <MeterDataSet> meterDataSets = new List <MeterDataSet>(); IEnumerable <Event> eventTable = (new TableOperations <Event>(connection)).QueryRecordsWhere("FileGroupID = {0}", fileGroup.ID); MeterDataSet meterDataSet; DataGroup dataGroup; foreach (IGrouping <int, Event> eventGroup in eventTable.GroupBy(evt => evt.MeterID)) { meterDataSet = new MeterDataSet(); meterDataSet.Meter = (new TableOperations <Meter>(connection)).QueryRecordWhere("ID = {0}", eventGroup.Key); meterDataSet.Meter.ConnectionFactory = () => new AdoDataConnection(connection.Connection, typeof(SqlDataAdapter), false); foreach (Event evt in eventGroup) { dataGroup = new DataGroup(); dataGroup.FromData(meterDataSet.Meter, (new TableOperations <EventData>(connection)).QueryRecordWhere("ID = {0}", evt.EventDataID).TimeDomainData); foreach (DataSeries dataSeries in dataGroup.DataSeries) { meterDataSet.DataSeries.Add(dataSeries); } } meterDataSets.Add(meterDataSet); } return(meterDataSets); }
public static void NewPrimaryFile(ref FileGroup fileGroup, string dataFolderPath, double?initialSize = null, double?fileGrowth = null, FileGrowthType?growthType = null, double?maxSize = null) { string fileName = string.Format(PRIMARY_FILE_FORMAT, dataFolderPath, fileGroup.Parent.Name); if (!fileGrowth.HasValue || !growthType.HasValue) { KeyValuePair <double, FileGrowthType> autoGrowth = GetModelDBAutoGrowth(); fileGrowth = autoGrowth.Key; growthType = autoGrowth.Value; } if (!initialSize.HasValue) { initialSize = GetModelDBInitialSize(); } if (!maxSize.HasValue) { maxSize = GetModelDBMaxSize(); } fileGroup.Files.Add(new DataFile(fileGroup, Path.GetFileNameWithoutExtension(fileName)) { FileName = fileName, IsPrimaryFile = true, Growth = fileGrowth.Value, GrowthType = growthType.Value, MaxSize = maxSize.Value, Size = initialSize.Value }); }
public void PopulateCredentialsProfiles(FileGroup file) { if (_credentialsUI != null) { _credentialsUI.PopulateCredentialsProfiles(file); } }
/// <summary> /// Create a new file and save the file group. /// </summary> /// <param name="fileGroup">The file group defining the new file.</param> public void CreateFile(FileGroup fileGroup) { fileGroup.SaveFields(); if (!File.Exists(BuildFilePath(fileGroup.FilePath, fileGroup.FileName).Replace('/', '\\'))) { var dataDef = Settings.FindBaseFile(fileGroup.BaseFileName); var f = GenDataBase.DataLoader.LoadData(BuildFilePath(dataDef.FilePath, dataDef.FileName)).AsDef(); var d = new GenDataBase(f); var fileName = BuildFilePath(fileGroup.FilePath, fileGroup.FileName); GenParameters.SaveToFile(d, fileName); } if (Settings.FindFileGroup(fileGroup.Name) == null) { Settings.Model.GenSettingsList[0].AddFileGroup(fileGroup.Name, fileGroup.FileName, fileGroup.FilePath, fileGroup.BaseFileName, fileGroup.Profile, fileGroup.GeneratedFile); } if (fileGroup.BaseFileName == "Definition") { AddBaseFile(fileGroup); } SetFileGroup(fileGroup.Name); SaveSettings(); }
public IOutput Create() { var group = new FileGroup("Responses"); var sb = new StringBuilder(); sb.Al($"namespace {_module.Namespace}.Core.Responses"); sb.Al("{"); sb.I(1).Al("public class PagedListResponse<T>"); sb.I(1).Al("{"); sb.I(2).Al("public IReadOnlyList<T> Items { get; }"); sb.I(2).Al("public long TotalItemCount { get; }"); sb.I(2).Al("public bool HasNextPage { get; }"); sb.I(2).Al("public PagedListResponse(IEnumerable<T> items, long totalItemCount, bool hasNextPage)"); sb.I(2).Al("{"); sb.I(3).Al("Items = items.ToList();"); sb.I(3).Al("TotalItemCount = totalItemCount;"); sb.I(3).Al("HasNextPage = hasNextPage;"); sb.I(2).Al("}"); sb.I(1).Al("}"); sb.Al("}"); group.AddFile(new File("PagedListResponse.cs", sb.ToString(), canOverwrite: true)); return(group); }
private TreeListNode addFileGroupToTree( TreeListNode parentNode, FileGroup fileGroup) { if (_ignoreFileGroup != null && _ignoreFileGroup.UniqueID == fileGroup.UniqueID) { return(null); } var fileGroupNode = AppendNode( new object[] { null }, parentNode); // -- updateFileGroupInTree( fileGroupNode, fileGroup); // -- return(fileGroupNode); }
public IOutput AddFileGroup(IOutput output) { if (output is null) { var emptyFg = _fileGroups.FirstOrDefault(f => string.IsNullOrWhiteSpace(f.Name)); if (emptyFg is null) { emptyFg = new FileGroup(); } return(emptyFg); } if (output is not IFileGroup fileGroup) { return(Output.Empty); } var exsiting = _fileGroups.FirstOrDefault(f => f.Name == fileGroup.Name); if (exsiting is null) { _fileGroups.Add(fileGroup); return(fileGroup); } else { foreach (var file in fileGroup.Files) { exsiting.AddFile(file); } return(exsiting); } }
public void TakeFullSnapshot( FileGroup[] fileGroups, string[] languageCodes, // Source _and_ destination. BackgroundWorker bw) { languageCodes = make2(languageCodes); bw.ReportProgress(0, Resources.SnapshotController_TakeFullSnapshot_Taking_snapshots_); var fgIndex = 0; foreach (var fileGroup in fileGroups) { bw.ReportProgress( 0, string.Format( Resources.SnapshotController_TakeFullSnapshot_Taking_snapshot__0__of__1__for_file_group___2_____, fgIndex + 1, fileGroups.Length, fileGroup.GetNameIntelligent(Project))); if (bw.CancellationPending) { throw new OperationCanceledException(); } doTakeSnapshot(fileGroup, languageCodes, bw); fgIndex++; } }
/// <summary> /// Creates the build database /// </summary> /// <param name="sqlServer">The server instance against which the build database must be deployed</param> /// <param name="databaseName">The name of the new database</param> private void CreateDatabase(Server sqlServer, string databaseName) { if (sqlServer.Databases.Contains(databaseName)) { // assume the previous extract crashed without clean up -> drop the databaseName and allow clean create: this.database = sqlServer.Databases[databaseName]; this.DropDatabase(); } Utilities.Logger.LogInformation("Creating temporary build database {0}...", databaseName); this.database = new Database(sqlServer, databaseName); FileGroup fg = new FileGroup(this.database, "PRIMARY"); DataFile df = new DataFile(fg, string.Concat("DB_Build", databaseName, "_Data"), Path.Combine(sqlServer.Information.MasterDBPath, databaseName + ".mdf")); df.Size = 20480; df.GrowthType = FileGrowthType.KB; df.Growth = 20480; fg.Files.Add(df); this.database.FileGroups.Add(fg); LogFile lf = new LogFile(this.database, string.Concat("DB_Build", databaseName, "_Log"), Path.Combine(sqlServer.Information.MasterDBPath, databaseName + ".ldf")); lf.Size = 10240; lf.GrowthType = FileGrowthType.KB; lf.Growth = 10240; this.database.LogFiles.Add(lf); this.database.Create(); }
public static FileGroup NewPrimaryFileGroup(ref Database newDb) { var primaryFG = new FileGroup(newDb, "PRIMARY"); newDb.FileGroups.Add(primaryFG); return(primaryFG); }
/// <summary> /// Creates a database /// </summary> /// <param name="sqlServer">The server instance where the database should be created</param> /// <param name="targetDatabase">The name of the database to create</param> /// <returns>The Database if successful</returns> private Database CreateDatabase(Server sqlServer, string targetDatabase) { Database database; if (sqlServer.Databases.Contains(targetDatabase)) { database = sqlServer.Databases[targetDatabase]; } else { Utilities.Logger.LogInformation("Creating new database {0}...", targetDatabase); database = new Database(sqlServer, targetDatabase); database.CompatibilityLevel = CompatibilityLevel.Version90; FileGroup fg = new FileGroup(database, "PRIMARY"); DataFile df = new DataFile(fg, string.Concat(targetDatabase, "_Data"), Path.Combine(sqlServer.Information.MasterDBPath, targetDatabase + ".mdf")); df.Size = 20480; df.GrowthType = FileGrowthType.KB; df.Growth = 20480; fg.Files.Add(df); database.FileGroups.Add(fg); LogFile lf = new LogFile(database, string.Concat(targetDatabase, "_Log"), Path.Combine(sqlServer.Information.MasterDBPath, targetDatabase + ".ldf")); lf.Size = 10240; lf.GrowthType = FileGrowthType.KB; lf.Growth = 10240; database.LogFiles.Add(lf); database.Create(); Utilities.Logger.LogInformation("Database {0} creation complete ...", targetDatabase); } return(database); }
/// <summary> /// Opens the with dialog. /// </summary> public void OpenWithDialog() { using (var ofd = new OpenFileDialog()) { ofd.Multiselect = true; ofd.Filter = $@"{Resources.SR_MainForm_openToolStripMenuItemClick_ResourceFiles} (*.resx;*.resw)|*.resx;*.resw"; ofd.RestoreDirectory = true; var initialDir = ConvertHelper.ToString( PersistanceHelper.RestoreValue( MainForm.UserStorageIntelligent, @"filesInitialDir")); ofd.InitialDirectory = initialDir; if (ofd.ShowDialog(this) == DialogResult.OK) { PersistanceHelper.SaveValue( MainForm.UserStorageIntelligent, @"filesInitialDir", ZlpPathHelper.GetDirectoryPathNameFromFilePath(ofd.FileName)); var fileGroup = FileGroup.CheckCreate( MainForm.Current.ProjectFilesControl.Project ?? Project.Empty, ofd.FileNames); bool isNew; var editorControl = checkGetAddEditorControl(fileGroup, out isNew); editorControl.OpenWithDialog(fileGroup); } } }
private static Database CreateDb(Server server, string databaseName, string directory) { Database db = new Database(server, databaseName); db.DatabaseOptions.AutoClose = true; db.DatabaseOptions.AutoShrink = true; db.DatabaseOptions.UserAccess = DatabaseUserAccess.Multiple; FileGroup fileGroup = new FileGroup(db, "PRIMARY"); db.FileGroups.Add(fileGroup); DataFile dataFile = new DataFile(fileGroup, databaseName + "_Data"); fileGroup.Files.Add(dataFile); dataFile.FileName = Path.Combine(Path.GetFullPath(directory), databaseName + ".mdf"); dataFile.Size = 5.0 * 1024.0; dataFile.Growth = 10.0; dataFile.GrowthType = FileGrowthType.Percent; LogFile logFile = new LogFile(db, databaseName + "_Log"); db.LogFiles.Add(logFile); logFile.FileName = Path.Combine(Path.GetFullPath(directory), databaseName + ".ldf"); logFile.Size = 2.5 * 1024.0; logFile.GrowthType = FileGrowthType.Percent; logFile.Growth = 10.0; db.Create(false); return db; }
private int GetRemoteFileGroup(string address, int localFileGroupId) { FileGroup local = DataContext.Table <FileGroup>().QueryRecordWhere("ID = {0}", localFileGroupId); List <FileGroup> remote = WebAPIHub.GetRecords(address, "FileGroup", "all").Select(x => (FileGroup)x).ToList(); int id; if (local != null && !remote.Where(x => x.DataStartTime.Equals(local.DataStartTime) && x.DataEndTime.Equals(local.DataEndTime) && x.ProcessingStartTime.Equals(local.ProcessingStartTime) && x.ProcessingEndTime.Equals(local.ProcessingEndTime)).Any()) { FileGroup record = new FileGroup() { DataStartTime = local.DataStartTime, DataEndTime = local.DataEndTime, ProcessingStartTime = local.ProcessingStartTime, ProcessingEndTime = local.ProcessingEndTime, Error = local.Error, FileHash = local.FileHash }; id = WebAPIHub.CreateRecord(address, "FileGroup", JObject.FromObject(record)); } else { id = remote.Where(x => x.DataStartTime.Equals(local.DataStartTime) && x.DataEndTime.Equals(local.DataEndTime) && x.ProcessingStartTime.Equals(local.ProcessingStartTime) && x.ProcessingEndTime.Equals(local.ProcessingEndTime)).First().ID; } SyncDataFiles(address, localFileGroupId, id); return(id); }
/// <summary>Implements the Exec method of the IDTCommandTarget interface. This is called when the command is invoked.</summary> /// <param term='commandName'>The name of the command to execute.</param> /// <param term='executeOption'>Describes how the command should be run.</param> /// <param term='varIn'>Parameters passed from the caller to the command handler.</param> /// <param term='varOut'>Parameters passed from the command handler to the caller.</param> /// <param term='handled'>Informs the caller if the command was handled or not.</param> /// <seealso class='Exec' /> public void Exec(string commandName, vsCommandExecOption executeOption, ref object varIn, ref object varOut, ref bool handled) { //System.Windows.Forms.MessageBox.Show("exec"); handled = false; if(executeOption == vsCommandExecOption.vsCommandExecOptionDoDefault && AcceptedCommand(commandName)) { bool bForward = true; if(commandName == "FileSwitch2008.Connect.PrevFile") { bForward = false; } Project fileproject = _addInInstance.DTE.ActiveDocument.ProjectItem.ContainingProject; string fullname =_addInInstance.DTE.ActiveDocument.FullName; FileGroup group = new FileGroup(fileproject, fullname.ToLower()); string newfile = bForward ? group.Next() : group.Prev(); _applicationObject.ItemOperations.OpenFile(newfile, Constants.vsViewKindCode); handled = true; return; } }
private static void FillFiles(FileGroup filegroup, string connectionString) { using (SqlConnection conn = new SqlConnection(connectionString)) { using (SqlCommand command = new SqlCommand(GetSQLFile(filegroup), conn)) { conn.Open(); using (SqlDataReader reader = command.ExecuteReader()) { while (reader.Read()) { FileGroupFile item = new FileGroupFile(filegroup); item.Id = (int)reader["file_id"]; item.Name = reader["name"].ToString(); item.Owner = ""; item.Growth = (int)reader["growth"]; item.IsPercentGrowth = (bool)reader["is_percent_growth"]; item.IsSparse = (bool)reader["is_sparse"]; item.MaxSize = (int)reader["max_size"]; item.PhysicalName = reader["physical_name"].ToString(); item.Size = (int)reader["size"]; item.Type = (byte)reader["type"]; filegroup.Files.Add(item); } } } } }
public IOutput Create() { var projectName = _module.Namespace + ".Common"; var project = (IProject) new Project(projectName) { Path = System.IO.Path.Combine("src", projectName) }; var files = new FileGroup(); project.AddFileGroup(files); var sb = new StringBuilder(); sb.Al("<Project Sdk=\"Microsoft.NET.Sdk\">"); sb.B(); sb.I(1).Al("<PropertyGroup>"); sb.I(2).Al("<TargetFramework>net5.0</TargetFramework>"); sb.I(2).Al($"<RootNamespace>{project.Name}</RootNamespace>"); sb.I(2).Al("<LangVersion>Preview</LangVersion>"); sb.I(2).Al($"<Nullable>enable</Nullable>"); sb.I(1).Al("</PropertyGroup>"); sb.B(); sb.I(1).Al("<ItemGroup>"); sb.I(2).Al($"<PackageReference Include=\"CSharpFunctionalExtensions\" Version=\"{Settings.Packages.GetVersion("CSharpFunctionalExtensions", "2.17.0")}\" />"); sb.I(1).Al("</ItemGroup>"); sb.B(); sb.Al("</Project>"); var projectFile = new File(project.Name + ".csproj", sb.ToString()); files.AddFile(projectFile); return(project); }
/// <summary> /// 利用SMO创建数据库 /// </summary> public static void CreateDatabase(string databaseName, string dbPath) { try { //创建ServerConnection的实例 ServerConnection connection = new ServerConnection(); //指定连接字符串 connection.ConnectionString = @"Data Source=.\ACALSQLEXPRESS;Initial Catalog=master;User ID=sa;Password=ACal@Server123456;"; //"Data Source=goodapp;Initial Catalog=master;User ID=sa;Password=root;"; //实例化Server Server server = new Server(connection); #region [创建数据库对象] //检查在数据库是否已经存在该数据库 var queryDatabase = from Database temp in server.Databases where string.Equals(temp.Name, databaseName, StringComparison.CurrentCultureIgnoreCase) select temp; Database database = queryDatabase.FirstOrDefault <Database>(); //如果存在就删除 if (database != null) { database.Drop(); } database = new Database(server, databaseName); //指定数据库数据文件细节 FileGroup fileGroup = new FileGroup { Name = "PRIMARY", Parent = database, IsDefault = false }; DataFile dataFile = new DataFile { Name = databaseName + "_data", Parent = fileGroup, FileName = dbPath + databaseName + ".mdf" }; fileGroup.Files.Add(dataFile); //指定数据库日志文件细节 LogFile logFile = new LogFile { Name = databaseName + "_log", Parent = database, FileName = dbPath + databaseName + ".ldf" }; database.FileGroups.Add(fileGroup); database.LogFiles.Add(logFile); database.Create(); #endregion } catch (Exception exc) { var message = exc.Message; Console.WriteLine(exc.ToString()); } finally { //Console.ReadKey(); } }
/// <summary> /// Open form for saving open files as a group. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void saveOpenFilesAsGroupToolStripMenuItem_Click(object sender, EventArgs e) { if (tabControl1.TabPages.Count > 0) { var groupForm = new CreateGroupForm { StartPosition = FormStartPosition.CenterParent }; var result = groupForm.ShowDialog(); if (result != DialogResult.OK) { return; } var tabFiles = ( from TabPage tabPage in tabControl1.TabPages select new TabFile { TabName = tabPage.Text, File = tabPage.ToolTipText, Name = tabPage.Name }) .ToList(); var group = new FileGroup { GroupName = groupForm.name, Tabfiles = tabFiles }; _groups.FileGroups.Add(@group); FileGroupHandler.Save(_groups); } else { MessageBox.Show("No open files to group."); } }
public IOutput Create() { var group = new FileGroup("Aggregates"); var sb = new StringBuilder(); sb.Al($"namespace {_module.Namespace}.Core.Aggregates"); sb.Al("{"); sb.I(1).Al("public abstract class Aggregate: Aggregate<Guid>, IAggregate"); sb.I(1).Al("{ }"); sb.B(); sb.I(1).Al("public abstract class Aggregate<T>: IAggregate<T> where T : notnull"); sb.I(1).Al("{"); sb.B(); sb.I(2).Al("public T Id { get; protected set; } = default!;"); sb.B(); sb.I(2).Al("public int Version { get; protected set; }"); sb.B(); sb.I(2).Al("[NonSerialized] private readonly Queue<IEvent> uncommittedEvents = new Queue<IEvent>();"); sb.B(); sb.I(2).Al("public virtual void When(object @event) { }"); sb.B(); sb.I(2).Al("public IEvent[] DequeueUncommittedEvents()"); sb.I(2).Al("{"); sb.I(3).Al("var dequeuedEvents = uncommittedEvents.ToArray();"); sb.B(); sb.I(3).Al("uncommittedEvents.Clear();"); sb.B(); sb.I(3).Al("return dequeuedEvents;"); sb.I(2).Al("}"); sb.B(); sb.I(2).Al("protected void Enqueue(IEvent @event)"); sb.I(2).Al("{"); sb.I(3).Al("uncommittedEvents.Enqueue(@event);"); sb.I(2).Al("}"); sb.I(1).Al("}"); sb.Al("}"); group.AddFile(new File("Aggregate.cs", sb.ToString(), canOverwrite: true)); sb.Clear(); sb.Al($"namespace {_module.Namespace}.Core.Aggregates"); sb.Al("{"); sb.I(1).Al("public interface IAggregate: IAggregate<Guid>"); sb.B(); sb.I(1).Al("{ }"); sb.B(); sb.I(1).Al("public interface IAggregate<out T>: IProjection"); sb.I(1).Al("{"); sb.I(2).Al("T Id { get; }"); sb.I(2).Al("int Version { get; }"); sb.B(); sb.I(2).Al("IEvent[] DequeueUncommittedEvents();"); sb.I(1).Al("}"); sb.Al("}"); group.AddFile(new File("IAggregate.cs", sb.ToString(), canOverwrite: true)); return(group); }
public static Event GetEvent(this TableOperations <Event> eventTable, FileGroup fileGroup, DataGroup dataGroup) { int fileGroupID = fileGroup.ID; int lineID = dataGroup.Line.ID; DateTime startTime = dataGroup.StartTime; DateTime endTime = dataGroup.EndTime; int samples = dataGroup.Samples; IDbDataParameter startTimeParameter = new SqlParameter() { ParameterName = nameof(dataGroup.StartTime), DbType = DbType.DateTime2, Value = startTime }; IDbDataParameter endTimeParameter = new SqlParameter() { ParameterName = nameof(dataGroup.EndTime), DbType = DbType.DateTime2, Value = endTime }; RecordRestriction recordRestriction = new RecordRestriction("FileGroupID = {0}", fileGroupID) & new RecordRestriction("LineID = {0}", lineID) & new RecordRestriction("StartTime = {0}", startTimeParameter) & new RecordRestriction("EndTime = {0}", endTimeParameter) & new RecordRestriction("Samples = {0}", samples); return(eventTable.QueryRecord(recordRestriction)); }
private static string generateWorksheetName( PreparedInformation preparedInformation, FileGroup fileGroup, Project project) { // http://social.msdn.microsoft.com/Forums/en-US/vsto/thread/84c0c4d2-52b9-4502-bece-fdc616db05f8 const int maxLength = 31; var ni = (preparedInformation.UseCrypticExcelExportSheetNames ? fileGroup.UniqueID.ToString() : fileGroup.GetNameIntelligent(project)) .Replace('\\', '#') .Replace('/', '#') .Replace('?', '_') .Replace('*', '_') .Replace('[', '_') .Replace(']', '_') .Replace(':', '_'); //var cs = fileGroup.Checksum.ToString(); //var s1 = string.Format( @" ({0})", cs ); //var len = maxLength - s1.Length; var ni2 = FileGroup.ShortenFilePath(ni, maxLength); return(ni2); }
private static string GetFilesInFileGroup2008(FileGroup filegroup) { StringBuilder sql = new StringBuilder(); sql.Append("select file_id,type,name,physical_name,size,max_size,growth,is_sparse,is_percent_growth "); sql.Append("from sys.database_files WHERE data_space_id = " + filegroup.Id.ToString()); return(sql.ToString()); }
private static List <XElement> GetPathElements(FileGroup fileGroup) { List <XElement> pathElements = fileGroup.DataFiles .Select(dataFile => new XElement("path", dataFile.FilePath)) .ToList(); return(pathElements); }
private static string GetFilesInFileGroup2000(FileGroup filegroup) { StringBuilder sql = new StringBuilder(); sql.Append("select convert(int,fileid) as file_id,type=convert(tinyint,(status&64)/64),name,filename as physical_name,size,maxsize as max_size,growth,convert(bit,0) as is_sparse,is_percent_growth =convert(bit,status & 1048576) "); sql.Append("FROM sysfiles where groupid=" + filegroup.Id.ToString()); return(sql.ToString()); }
/// <summary> /// Gets the base name. /// </summary> /// <remarks> /// E.g. for: /// - Main.master.resx /// - Main.master.de.resx /// - Main.master.en-us.resx /// it would be "Main.master" /// /// E.g. for: /// - Properties.resx /// - Properties.de.resx /// it would be "Properties". /// </remarks> /// <value>The base name.</value> public string GetBaseName( FileGroup fileGroup) { string baseName; string extension; string optionalDefaultType; doGetBaseName( fileGroup, out baseName, out extension, out optionalDefaultType); return baseName; }
public void CreateSnapshot(DbConnectionInfo connectionInfo, string databaseName, string snapshotDatabaseName = null) { if (connectionInfo == null) throw new ArgumentNullException("connectionInfo must be initialized to create a snapshot."); if (string.IsNullOrWhiteSpace(databaseName)) throw new ArgumentNullException("databaseName is required to create a snapshot."); // 1. Initiate db connection Server server = connectionInfo.GetServer(); // 2. Check if DB Exists Database db = server.Databases[databaseName]; if (db == null) throw new ArgumentOutOfRangeException(string.Format("The database {0} does not exists.", databaseName)); var snapshot = db.IsDatabaseSnapshot; var hasSnapshots = db.IsDatabaseSnapshotBase; string dbSnapshotName = string.IsNullOrWhiteSpace(snapshotDatabaseName) ? databaseName + "_" + DateTime.UtcNow.ToString("yyMMdd") : snapshotDatabaseName; Database snapshotDatabase = new Database(server, dbSnapshotName); snapshotDatabase.DatabaseSnapshotBaseName = db.Name; foreach (FileGroup fileGroup in db.FileGroups) { FileGroup fg = new FileGroup(snapshotDatabase, fileGroup.Name); snapshotDatabase.FileGroups.Add(fg); } foreach (FileGroup fileGroup in db.FileGroups) { foreach (DataFile dataFile in fileGroup.Files) { var df = new DataFile(snapshotDatabase.FileGroups[fileGroup.Name], dataFile.Name, Path.Combine(db.PrimaryFilePath, string.Format("{0}_{1}.ss", dataFile.Name, snapshotDatabaseName))); snapshotDatabase.FileGroups[fileGroup.Name].Files.Add(df); } } // 3. snapshotDatabase.Create(); }
private bool isMatchingFileGroup(FileGroup group) { foreach (var allowedGroup in _groups) { if (allowedGroup.GetChecksum(_project) == group.GetChecksum(_project)) { return true; } } return false; }
private void buttonOK_Click(object sender, EventArgs e) { _result = null; using (new WaitCursor(this, WaitCursorOption.ShortSleep)) { var cultures = getCultures(); var baseFolderPath = baseFolderTextEdit.Text.Trim(); var baseFileName = baseFileNameTextEdit.Text.Trim(); var extension = @"." + extensionComboBoxEdit.Text.Trim('.'); var created = 0; using (new BackgroundWorkerLongProgressGui( delegate(object snd, DoWorkEventArgs args) { try { var bw = (BackgroundWorker)snd; // -- // First pass, add all in-memory to check for same file group. var fg = new FileGroup(_project); if (cultures != null) { foreach (var culture in cultures) { var fileName = _project.IsNeutralLanguage(culture) ? baseFileName + extension : generateFileName(fg, culture); fg.Add(new FileInformation(fg) { File = new ZlpFileInfo(fileName) }); } // Look for same entries. if (_project.FileGroups.HasFileGroupWithChecksum( fg.GetChecksum(_project))) { throw new MessageBoxException( this, Resources.SR_ProjectFilesUserControl_AddResourceFilesWithDialog_ExistsInTheProject, MessageBoxIcon.Information); } else { // -- // Second pass, add all existing. fg = new FileGroup(_project); foreach (var culture in cultures) { if (bw.CancellationPending) { throw new OperationCanceledException(); } var fileName = _project.IsNeutralLanguage(culture) ? baseFileName + extension : generateFileName(fg, culture); FileInformation ffi; if (_project.IsNeutralLanguage(culture)) { ffi = new FileInformation(fg) { File = new ZlpFileInfo(ZlpPathHelper.Combine(baseFolderPath, fileName)) }; fg.Add(ffi); } else { ffi = fg.CreateAndAddNewFile( baseFolderPath, fileName, culture.Name); } // Must create real file. ZlpIOHelper.WriteAllText(ffi.File.FullName, Resources.SR_EmptyResourceFile); created++; } } } if (_projectFolder != null) { fg.ProjectFolder = _projectFolder; } _project.FileGroups.Add(fg); _project.MarkAsModified(); _result = fg; } catch (OperationCanceledException) { // Ignore. } }, Resources.SR_CreateNewFilesForm_Creating, BackgroundWorkerLongProgressGui.CancellationMode.Cancelable, this)) { } // -- XtraMessageBox.Show( this, string.Format( Resources.SR_CreateNewFilesForm_Finished03, created), @"Zeta Resource Editor", MessageBoxButtons.OK, MessageBoxIcon.Information); } }
internal bool OpenWithDialog( FileGroup fileGroup) { var r = DoSaveFiles( SaveOptions.OnlyIfModified | SaveOptions.AskConfirm); if (r == DialogResult.OK) { DoLoadFiles(fileGroup, fileGroup.Project); // Immediately stores. MainForm.AddMruFiles(fileGroup.JoinedFilePaths); GridEditableData = fileGroup; return true; } else { return false; } }
public void FileGroupWriter(string name, int count,int size, bool withidx, bool isdefault,string test){ var fg = new FileGroup{Name = name, FileCount = count, FileSize = size, WithIndex = withidx, IsDefault = isdefault}; var writer = new FileGroupWriter(fg){NoComment = true, NoDelimiter = true,Mode = ScriptMode.Create,Dialect = DbDialect.SqlServer}; Assert.AreEqual(test,writer.ToString().Trim()); }
private void CreateDatabase(string dbFilename, string dbName, string remoteDbFilename) { Log.Inform("Database not found - creating..."); var accFile = dbFilename; if (remoteDbFilename.IsNotNullOrEmpty()) accFile = remoteDbFilename; var dir = Path.GetDirectoryName(accFile); if (dir.IsNotNullOrEmpty()) { if (!Directory.Exists(dir)) { Log.Inform("Creating database directory: " + dir); Directory.CreateDirectory(dir); } } Database = new Database(server, dbName); var fileGroup = new FileGroup(Database, "PRIMARY"); var dataFile = new DataFile(fileGroup, dbFilename, dbFilename); dataFile.Growth = 1024; dataFile.GrowthType = FileGrowthType.KB; fileGroup.Files.Add(dataFile); Database.FileGroups.Add(fileGroup); Database.DatabaseOptions.AutoShrink = true; server.Databases.Add(new Database(server, dbName)); Database.Create(); //server.AttachDatabase(sb.AttachDBFilename, new StringCollection { sb.AttachDBFilename }); }
public void Initialize( FileGroup fileGroup) { _fileGroup = fileGroup; }
internal void Initialize( FileGroup fileGroup ) { _fileGroup = fileGroup; }
// ADDED: adds resources from file Info lists. // I have changed a method doAutomaticallyAddResourceFiles to fill file groups. // You can use same method if you call this method from there. // ATTENTION: LanguageCodeDetection was modified a bit to support variable amount // of point in base name. New method GetBaseName(IInheritedSettings settings, string fileName) // was added to get same base name FileGroup gets. public void DoAutomaticallyAddResourceFilesFromList( BackgroundWorker backgroundWorker, ProjectFolder parentProjectFolder, ref int fileGroupCount, ref int fileCount, ICollection<ZlpFileInfo> fileList) { if (backgroundWorker.CancellationPending) { throw new OperationCanceledException(); } else if (fileList != null && fileList.Count > 0) { var fileGroups = Project.FileGroups; //if (parentProjectFolder != null) //{ // fileGroups = parentProjectFolder.ChildFileGroups; //} foreach (var filePath in fileList) { if (backgroundWorker.CancellationPending) { throw new OperationCanceledException(); } //other algorithm to determine base name to allow multiple points inside name var baseFileName = LanguageCodeDetection.GetBaseName(Project, filePath.Name); var wantAddResourceFile = checkWantAddResourceFile(filePath); if (wantAddResourceFile) { //find right file group var path = filePath; var fileGroup = fileGroups.Find( g => string.Compare(g.BaseName, baseFileName, true) == 0 && string.Compare(g.FolderPath.FullName, path.Directory.FullName, true) == 0); if (fileGroup == null) { fileGroup = new FileGroup(Project) { ProjectFolder = parentProjectFolder }; // Look for same entries. if (!Project.FileGroups.HasFileGroupWithChecksum( fileGroup.GetChecksum(Project))) { fileGroups.Add(fileGroup); fileGroupCount++; } } fileGroup.Add( new FileInformation(fileGroup) { File = filePath }); fileCount++; } } } }
public static void CopyDatabase(MyArgs parms) { //remove trailing slash on the path if provided by user if (parms.PathToLocalMdf.EndsWith("\\")) parms.PathToLocalMdf = parms.PathToLocalMdf.Substring(0, parms.PathToLocalMdf.Length - 1); //Set Source SQL Server (SQL Azure) Server sourceServer = new Server(new ServerConnection(parms.SourceServer, parms.SourceUser, parms.SourcePassword)); Database sourceDatabase = sourceServer.Databases[parms.SourceDatabase]; //Set Destination SQL Server (SQL IaaS) Server destServer = new Server(new ServerConnection(parms.DestinationServer, parms.DestinationUser, parms.DestinationPassword)); Database destDatabase = null; //Drop the detination database if it exits if (destServer.Databases.Contains(parms.DestinationDatabase)) { Console.Write($"Destintation DB {parms.DestinationDatabase} on {destServer.Name} Exists. Dropping."); destServer.KillDatabase(parms.DestinationDatabase); Console.WriteLine(" . . . Done!"); } //create the temp database on SQL IaaS Console.Write($"Creating Destintation DB {parms.DestinationDatabase} on {destServer.Name}."); destDatabase = new Database(destServer, parms.DestinationDatabase); var fg = new FileGroup(destDatabase, "PRIMARY"); destDatabase.FileGroups.Add(fg); var df = new DataFile(fg, $"{parms.DestinationDatabase}_data"); fg.Files.Add(df); df.FileName = $"{parms.PathToLocalMdf}\\{parms.DestinationDatabase}.mdf"; df.IsPrimaryFile = true; df.Growth = 10; df.GrowthType = FileGrowthType.Percent; destDatabase.Create(); Console.WriteLine(" . . . Done!"); //Transfer the schema and data from SQL Azure to SQL IaaS Console.WriteLine("Starting Transfer..."); Transfer transfer = new Transfer(sourceDatabase); transfer.DataTransferEvent += (object sender, DataTransferEventArgs e) => { Console.WriteLine($"{e.DataTransferEventType}: {e.Message}"); }; transfer.CopyAllObjects = true; transfer.Options.WithDependencies = true; transfer.Options.Triggers = true; transfer.Options.Indexes = true; transfer.Options.ClusteredIndexes = true; transfer.Options.Default = true; transfer.Options.DriAll = true; transfer.CopyData = true; transfer.DestinationServer = parms.DestinationServer; transfer.DestinationDatabase = parms.DestinationDatabase; transfer.TransferData(); Console.WriteLine("Transfer Complete!"); //Create a backup credential in the SQL IaaS instance to perform the backup to Azure Blob Console.Write("Creating Backup Credential..."); if (destServer.Credentials.Contains("BackupCred")) { Console.Write(" Dropping "); destServer.Credentials["BackupCred"].Drop(); } Credential credential = new Credential(destServer, "BackupCred"); credential.Create(parms.StorageAccountName, parms.StorageKey); Console.WriteLine(" Complete!"); string storageEndpoint = $"https://{parms.StorageAccountName}.{parms.StorageEndpointBase}/{parms.StorageContainer}/{parms.StorageFileBase}-{DateTime.UtcNow:yyyy-MM-dd-HH-mm}.bak"; //Perform the backup from SQL IaaS to Azure Blob //https://msdn.microsoft.com/en-us/library/dn435916.aspx Console.WriteLine("Starting Backup..."); Backup backup = new Backup(); backup.Action = BackupActionType.Database; backup.Database = parms.DestinationDatabase; backup.Devices.Add(new BackupDeviceItem(storageEndpoint, DeviceType.Url, "BackupCred")); backup.CredentialName = "BackupCred"; backup.Incremental = false; backup.SqlBackup(destServer); Console.WriteLine("Backup Complete!"); }
private static string generateFileName( FileGroup fileGroup, CultureInfo culture) { var pattern = new LanguageCodeDetection(fileGroup.Project).IsNeutralCulture( fileGroup.ParentSettings, culture) ? fileGroup.Project.NeutralLanguageFileNamePattern : fileGroup.Project.NonNeutralLanguageFileNamePattern; pattern = pattern.Replace(@"[basename]", fileGroup.BaseName); pattern = pattern.Replace(@"[languagecode]", culture.Name); pattern = pattern.Replace(@"[extension]", fileGroup.BaseExtension); pattern = pattern.Replace(@"[optionaldefaulttypes]", fileGroup.BaseOptionalDefaultType); return pattern; }
private TreeListNode addFileGroupToTree( TreeListNode parentNode, FileGroup fileGroup) { var fileGroupNode = treeView.AppendNode( new object[] { null }, parentNode); // -- updateFileGroupInTree( fileGroupNode, fileGroup); // -- addFileGroupFilesToTree(fileGroupNode); // -- return fileGroupNode; }
/// <summary> /// Create a new database based on user input. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void CreateButton_Click(object sender, System.EventArgs e) { // Create the database Cursor csr = null; String sDatabaseName; Database db; FileGroup fg; DataFile df; LogFile lf; ListViewItem DatabaseListViewItem; try { csr = this.Cursor; // Save the old cursor this.Cursor = Cursors.WaitCursor; // Display the waiting cursor // Get the name of the new database sDatabaseName = NewDatabaseTextBox.Text; // Check for new non-zero length name if (sDatabaseName.Length == 0) { ExceptionMessageBox emb = new ExceptionMessageBox(); emb.Text = Properties.Resources.NoDatabaseName; emb.Show(this); return; } // Ensure we have the current list of databases to check. SqlServerSelection.Databases.Refresh(); // Refresh database list ShowDatabases(false); // Is database name new and unique? if (SqlServerSelection.Databases.Contains(sDatabaseName)) { ExceptionMessageBox emb = new ExceptionMessageBox(); emb.Text = Properties.Resources.DuplicateDatabaseName; emb.Show(this); return; } // Instantiate a new database object db = new Database(SqlServerSelection, sDatabaseName); // This may also be accomplished like so: // db = new Database(); // db.Parent = SqlServerSelection; // db.Name = sDatabaseName; // Create a new file group named PRIMARY fg = new FileGroup(db, @"PRIMARY"); // Create a new data file and add it to the file group's Files collection // Give the data file a physical filename using the master database path of the server df = new DataFile(fg, sDatabaseName + @"_Data0", SqlServerSelection.Information.MasterDBPath + @"\" + sDatabaseName + @"_Data0" + @".mdf"); // Set the growth type to KB df.GrowthType = FileGrowthType.KB; // Set the growth size in KB df.Growth = 1024; // Set initial size in KB (optional) df.Size = 10240; // Set the maximum size in KB df.MaxSize = 20480; // Add file to file group fg.Files.Add(df); // Create a new data file and add it to the file group's Files collection // Give the data file a physical filename using the master database path of the server df = new DataFile(fg, sDatabaseName + @"_Data1", SqlServerSelection.Information.MasterDBPath + @"\" + sDatabaseName + @"_Data1" + @".ndf"); // Set the growth type to KB df.GrowthType = FileGrowthType.KB; // Set the growth size in KB df.Growth = 1024; // Set initial size in KB (optional) df.Size = 2048; // Set the maximum size in KB df.MaxSize = 8192; // Add file to file group fg.Files.Add(df); // Add the new file group to the database's FileGroups collection db.FileGroups.Add(fg); // Create a new file group named SECONDARY fg = new FileGroup(db, @"SECONDARY"); // Create a new data file and add it to the file group's Files collection // Give the data file a physical filename using the master database path of the server df = new DataFile(fg, sDatabaseName + @"_Data2", SqlServerSelection.Information.MasterDBPath + @"\" + sDatabaseName + @"_Data2" + @".ndf"); // Set the growth type to KB df.GrowthType = FileGrowthType.KB; // Set the growth size in KB df.Growth = 512; // Set initial size in KB (optional) df.Size = 1024; // Set the maximum size in KB df.MaxSize = 4096; // Add file to file group fg.Files.Add(df); // Create a new data file and add it to the file group's Files collection // Give the data file a physical filename using the master database path df = new DataFile(fg, sDatabaseName + @"_Data3", SqlServerSelection.Information.MasterDBPath + @"\" + sDatabaseName + @"_Data3" + @".ndf"); // Set the growth type to KB df.GrowthType = FileGrowthType.KB; // Set the growth size in KB df.Growth = 512; // In KB // Set initial size in KB (optional) df.Size = 1024; // Set initial size in KB (optional) // Set the maximum size in KB df.MaxSize = 4096; // Add file to file group fg.Files.Add(df); // Add the new file group to the database's FileGroups collection db.FileGroups.Add(fg); // Define the database transaction log. lf = new LogFile(db, sDatabaseName + @"_Log", SqlServerSelection.Information.MasterDBPath + @"\" + sDatabaseName + @"_Log" + @".ldf"); // Set the growth type to KB lf.GrowthType = FileGrowthType.KB; // Set the growth size in KB lf.Growth = 1024; // In KB // Set initial size in KB (optional) lf.Size = 2048; // Set initial size in KB (optional) // Set the maximum size in KB lf.MaxSize = 8192; // In KB // Add file to file group db.LogFiles.Add(lf); // Create the database as defined. db.Create(); // Refresh database list ShowDatabases(false); // Find and select the database just created DatabaseListViewItem = DatabasesListView.FindItemWithText(sDatabaseName); DatabaseListViewItem.Selected = true; DatabaseListViewItem.EnsureVisible(); } catch (SmoException ex) { ExceptionMessageBox emb = new ExceptionMessageBox(ex); emb.Show(this); } finally { // Clean up. db = null; fg = null; df = null; lf = null; UpdateControls(); this.Cursor = csr; // Restore the original cursor } }
/// <summary> /// </summary> /// <param name="schema"></param> public FileGroupWriter(FileGroup schema){ FileGroup = schema; Parameters = FileGroup; }
/// <summary> /// Updates the file group in tree. /// </summary> /// <param name="fileGroupNode">The file group node.</param> /// <param name="fileGroup">The file group.</param> private void updateFileGroupInTree( TreeListNode fileGroupNode, FileGroup fileGroup) { fileGroupNode[0] = fileGroup.GetNameIntelligent(Project); fileGroupNode.ImageIndex = fileGroupNode.SelectImageIndex = getImageIndex(@"group"); fileGroupNode.Tag = fileGroup; fileGroupNode.StateImageIndex = (int)FileGroupStateColor.Grey; //(int)fileGroup.TranslationStateColor; updateNodeStateImage(fileGroupNode, AsynchronousMode.Asynchronous); UpdateUI(); }
public void AddExistingResourceFilesWithDialog() { using (var ofd = new OpenFileDialog()) { ofd.Multiselect = true; ofd.Filter = string.Format(@"{0} (*.resx;*.resw)|*.resx;*.resw", Resources.SR_MainForm_openToolStripMenuItemClick_ResourceFiles); ofd.RestoreDirectory = true; var initialDir = ConvertHelper.ToString( PersistanceHelper.RestoreValue( MainForm.UserStorageIntelligent, @"filesInitialDir")); ofd.InitialDirectory = initialDir; if (ofd.ShowDialog(this) == DialogResult.OK) { PersistanceHelper.SaveValue( MainForm.UserStorageIntelligent, @"filesInitialDir", ZlpPathHelper.GetDirectoryPathNameFromFilePath(ofd.FileName)); // -- var fileGroup = new FileGroup(Project); foreach (var filePath in ofd.FileNames) { fileGroup.Add(new FileInformation(fileGroup) { File = new ZlpFileInfo(filePath) }); } // Look for same entries. if (Project.FileGroups.HasFileGroupWithChecksum( fileGroup.GetChecksum(Project))) { throw new MessageBoxException( this, Resources.SR_ProjectFilesUserControl_AddResourceFilesWithDialog_ExistsInTheProject, MessageBoxIcon.Information); } else { var parentProjectFolder = treeView.SelectedNode.Tag as ProjectFolder; if (parentProjectFolder != null) { fileGroup.ProjectFolder = parentProjectFolder; } Project.FileGroups.Add(fileGroup); Project.MarkAsModified(); var node = addFileGroupToTree(treeView.SelectedNode, fileGroup); // -- sortTree(); treeView.SelectedNode = node; // Immediately open for editing. editResourceFiles(); UpdateUI(); } } } }
private void Create() { this.LogTaskMessage(string.Format(CultureInfo.CurrentCulture, "Creating Database: {0}", this.DatabaseItem.ItemSpec)); if (this.CheckDatabaseExists()) { if (this.Force) { this.Delete(); } else { this.Log.LogError(string.Format(CultureInfo.CurrentCulture, "Database already exists: {0}. Set Force to true to delete an existing Database.", this.DatabaseItem.ItemSpec)); return; } } SMO.Database newDatabase = new SMO.Database(this.sqlServer, this.DatabaseItem.ItemSpec); if (this.DataFilePath != null) { FileGroup fileGroup = new FileGroup(newDatabase, this.FileGroupName); DataFile dataFile = new DataFile(fileGroup, this.DatabaseItem.ItemSpec, this.DataFilePath.GetMetadata("FullPath")); fileGroup.Files.Add(dataFile); newDatabase.FileGroups.Add(fileGroup); } if (this.LogFilePath != null) { if (string.IsNullOrEmpty(this.LogName)) { this.LogName = this.DatabaseItem.ItemSpec + "_log"; } LogFile logFile = new LogFile(newDatabase, this.LogName, this.LogFilePath.GetMetadata("FullPath")); newDatabase.LogFiles.Add(logFile); } if (!string.IsNullOrEmpty(this.Collation)) { newDatabase.Collation = this.Collation; } newDatabase.Create(); }
static void Main(string[] args) { //Parse command line parameters Dictionary<string, string> param = new Dictionary<string, string>(); foreach (var v in args) { int p = v.IndexOf("="); if (p > 0) { param.Add(v.Substring(0, p), v.Substring(p + 1, v.Length - p - 1)); } } if (param.Count == 0) { //just show help ShowUsage(); WriteLine("Press any key to close"); Console.ReadKey(); Environment.Exit(0); } string server; string database; string newDatabase = null; string user = null; string password = null; string databaseFileName = ""; if (!param.TryGetValue("server", out server)) server = "."; if (!param.TryGetValue("db", out database)) WarnAndExit("\"db\" command line parameter was not specified"); if (!param.TryGetValue("newdb", out newDatabase)) newDatabase = null; if (!param.TryGetValue("user", out user)) user = null; if (!param.TryGetValue("password", out password)) password = null; if (!param.TryGetValue("filename", out databaseFileName)) databaseFileName = null; if (string.IsNullOrEmpty(newDatabase)) newDatabase = database + "_Unicode"; //Connect to the specified server ServerConnection connection = new ServerConnection(server); Database db = null; Server svr = null; if (string.IsNullOrEmpty(user)) { connection.LoginSecure = true; //Windows authentication } else { connection.LoginSecure = false; connection.Login = user; connection.Password = password; } try { svr = new Server(connection); db = svr.Databases[database]; } catch (Exception e) { WarnAndExit(string.Format("Could not connect to server \"{0}\": {1}", server, e.Message)); } if (db == null) WarnAndExit(string.Format("Database \"{0}\" does not exist on the server \"{1}\"", database, server)); //create new database Database newDB = svr.Databases[newDatabase]; if (newDB != null) { try { Notify(string.Format("Dropping the existing \"{0}\" database", newDatabase)); svr.KillAllProcesses(newDatabase); svr.KillDatabase(newDatabase); } catch (Exception e) { ReportException(e); } newDB = svr.Databases[newDatabase]; } if (newDB != null) { WriteLine(string.Format("Target database \"{0}\" already exists. All existing data will be deleted", newDatabase), OutputKind.Warning); //store views/tables/triggers in a list List<View> oldViews = new List<View>(); foreach (View v in newDB.Views) if (!v.IsSystemObject) oldViews.Add(v); List<Table> oldTables = new List<Table>(); foreach (Table t in newDB.Tables) if (!t.IsSystemObject) oldTables.Add(t); List<Trigger> oldTriggers = new List<Trigger>(); foreach (Trigger t in newDB.Triggers) if (!t.IsSystemObject) oldTriggers.Add(t); //delete 'em foreach (Trigger t in oldTriggers) t.Drop(); foreach (View v in oldViews) v.Drop(); foreach (Table t in oldTables) t.Drop(); } else { WriteLine(string.Format("Creating new database \"{0}\" ", newDatabase), OutputKind.Info); newDB = new Database(svr, newDatabase); newDB.Collation = db.Collation; newDB.DefaultSchema = db.DefaultSchema; //should it be "sysdba"? FileGroup dbFG = new FileGroup(newDB, "PRIMARY"); newDB.FileGroups.Add(dbFG); //Now add primary db file to file group if (string.IsNullOrEmpty(databaseFileName)) { string oldDatabaseFilename = db.FileGroups[0].Files[0].FileName; string directory = Path.GetDirectoryName(oldDatabaseFilename); databaseFileName = directory + @"\" + newDatabase + ".mdf"; } DataFile df1 = new DataFile(dbFG, "SalesLogix_Data"); dbFG.Files.Add(df1); df1.FileName = databaseFileName; df1.Size = 10.0*1024.0; df1.GrowthType = FileGrowthType.Percent; df1.Growth = 25.0; try { newDB.Create(); } catch (Exception e) { WriteLine(string.Format("Could not create database \"{0}\"", newDatabase), OutputKind.Error); ReportException(e); WarnAndExit(""); } } //copy the users foreach (User oldUser in db.Users) { User newUser = newDB.Users[oldUser.Name]; if (newUser == null) { Notify("Processing user " + oldUser.Name); try { newUser = new User(newDB, oldUser.Name); newUser.DefaultSchema = oldUser.DefaultSchema; newUser.UserType = oldUser.UserType; newUser.Login = oldUser.Login; newDB.Users.Add(newUser); newUser.Create(); StringCollection roles = oldUser.EnumRoles(); foreach (string role in roles) newUser.AddToRole(role); newUser.Alter(); } catch (Exception e) { ReportException(e); } } } //copy schemas foreach (Schema oldSchema in db.Schemas) { Schema newSchema = newDB.Schemas[oldSchema.Name]; if (newSchema == null) { Notify("Processing schema " + oldSchema.Name); try { newSchema = new Schema(newDB, oldSchema.Name); newSchema.Owner = oldSchema.Owner; newDB.Schemas.Add(newSchema); newSchema.Create(); } catch (Exception e) { ReportException(e); } } } //copy datatype foreach (UserDefinedDataType oldType in db.UserDefinedDataTypes) { UserDefinedDataType newType = newDB.UserDefinedDataTypes[string.Format("[{0}].[{1}]", oldType.Owner, oldType.Name)]; if (newType == null) newType = newDB.UserDefinedDataTypes[oldType.Name]; if (newType == null) { Notify("Processing user data type " + oldType.Name); try { newType = new UserDefinedDataType(newDB, oldType.Name, oldType.Schema); newType.Owner = oldType.Owner; //adjust the type correctly string systemType = oldType.SystemType; switch (systemType.ToUpper()) { case "VARCHAR": { systemType = "NVARCHAR"; break; } case "CHAR": { systemType = "NCHAR"; break; } case "TEXT": { systemType = "NTEXT"; break; } } newType.SystemType = systemType; newType.Length = oldType.Length; newType.Nullable = oldType.Nullable; newType.Default = oldType.Default; newType.DefaultSchema = oldType.DefaultSchema; newType.NumericPrecision = oldType.NumericPrecision; newType.NumericScale = oldType.NumericScale; newType.Rule = oldType.Rule; newType.RuleSchema = oldType.RuleSchema; newDB.UserDefinedDataTypes.Add(newType); newType.Create(); } catch (Exception e) { ReportException(e); } } } //copy the schema StringBuilder sb = new StringBuilder(); ScriptingOptions options = new ScriptingOptions(); options.ClusteredIndexes = true; options.Default = true; options.DriAll = true; options.Indexes = true; options.IncludeHeaders = true; options.DriAllConstraints = true; options.DriIndexes = true; options.FullTextIndexes = true; options.ExtendedProperties = true; options.NoCollation = true; //we will convert TEXT to NTEXT anyway options.NoCommandTerminator = false; //we do need this - otherwise CREATE VIEW has problems options.ClusteredIndexes = true; options.NonClusteredIndexes = true; options.SchemaQualify = true; options.ScriptSchema = true; options.SchemaQualifyForeignKeysReferences = true; options.IncludeDatabaseContext = false; //since we wil be executing in a different DB context options.Triggers = true; //copy tables foreach (Table table in db.Tables) { if (!table.IsSystemObject) { Table oldTable = newDB.Tables[table.Name]; if (oldTable != null) { try { Notify("Dropping existing table " + oldTable.Name); oldTable.Drop(); } catch (Exception e) { ReportException(e); } } sb.Length = 0; //don't script inserts - we run out of memory options.ScriptData = false; StringCollection coll = table.Script(options); foreach (string str in coll) { sb.AppendLine(str); } Notify("Creating table " + table.Name); string sql = ChangeAnsiToUnicode(sb.ToString()); try { newDB.ExecuteNonQuery(sql); } catch (Exception e) { ReportException(e, sql); } var x = Missing.Value; } } //copy views foreach (View view in db.Views) { if (!view.IsSystemObject) { View oldView = newDB.Views[view.Name]; if (oldView != null) { try { Notify("Dropping existing view " + oldView.Name); oldView.Drop(); } catch (Exception e) { ReportException(e); } } sb.Length = 0; StringCollection coll = view.Script(options); foreach (string str in coll) { string line = str; //make it a local avriable since we change it below if (line.Trim().StartsWith("create view", true, CultureInfo.CurrentCulture)) { //'CREATE VIEW' must be the first statement in a query batch. sb.AppendLine("GO"); //make sure we have the right schema when we call CREATE VIEW if ((line.ToUpper().IndexOf(".[" + view.Name.ToUpper()) < 0) && //if there is no preceeing "]." before [viewname], the schema is not specified (line.ToUpper().IndexOf("SYSDBA." + view.Name.ToUpper()) < 0)) { int p = line.ToUpper().IndexOf(string.Format("[{0}]", view.Name.ToUpper())); if (p >= 0) { line = line.Replace(string.Format("[{0}]", view.Name), string.Format("[sysdba].[{0}]", view.Name)); } else { p = line.ToUpper().IndexOf(string.Format("CREATE VIEW {0}", view.Name.ToUpper())); if (p >= 0) { line = line.ToUpper().Replace(string.Format("CREATE VIEW {0}", view.Name), string.Format("CREATE VIEW [sysdba].[{0}]", view.Name)); } } } } sb.AppendLine(line); } try { Notify("Creating view " + view.Name); newDB.ExecuteNonQuery(sb.ToString()); } catch (Exception e) { ReportException(e, sb.ToString()); } } } //now stuff existing data into the new db string connectionString = ""; if (string.IsNullOrEmpty(user)) { //Windows Auth connectionString = string.Format("Integrated Security=SSPI;Persist Security Info=False;Initial Catalog={0};Data Source={1}", newDatabase, server); } else { //SQL Auth connectionString = string.Format("Password={0};Persist Security Info=True;User ID={1};Initial Catalog={2};Data Source={3}", password, user, newDatabase, server); } SqlConnection newConnection = new SqlConnection(connectionString); newConnection.Open(); SqlBulkCopy bulkCopy = new SqlBulkCopy(newConnection); bulkCopy.BulkCopyTimeout = int.MaxValue; foreach (Table table in db.Tables) { if (!table.IsSystemObject) { try { Notify("Copying data to table " + table.Name); string sql = string.Format("SELECT * FROM {0}.{1}", table.Owner, table.Name); using (DataSet dataset = db.ExecuteWithResults(sql)) { bulkCopy.DestinationTableName = string.Format("{0}.{1}", table.Owner, table.Name); if (dataset.Tables.Count > 0) { DataTable t = dataset.Tables[0]; bulkCopy.WriteToServer(t); } } } catch (Exception e) { ReportException(e); } } GC.Collect(); //we can use lots of memory above! } //make sure the DB is marked as Unicode string markAsUnicodeSQL = "UPDATE SYSDBA.SYSTEMINFO SET UNICODE = 'T' "; try { Notify("Marking the new database as Unicode enabled"); newDB.ExecuteNonQuery(markAsUnicodeSQL); } catch (Exception e) { ReportException(e, markAsUnicodeSQL); } //convert the virtual file system Notify("Updating VIRTUALFILESYSTEM table..."); try { //we need a conneciton for updates since SMO won't let us use parameters for updates //when we update large binary fields (VIRTUALFILESYSTEM.ITEMDATA) string updateConnectionString = ""; if (string.IsNullOrEmpty(user)) { //Windows Auth updateConnectionString = string.Format("Integrated Security=SSPI;Persist Security Info=False;Initial Catalog={0};Data Source={1}", newDatabase, server); } else { //SQL Auth updateConnectionString = string.Format("Password={0};Persist Security Info=True;User ID={1};Initial Catalog={2};Data Source={3}", password, user, newDatabase, server); } SqlConnection updateConnection = new SqlConnection(updateConnectionString); updateConnection.Open(); string vfsSql = "SELECT VIRTUALFILESYSTEMID, ITEMNAME, ITEMDATA, ISCOMPRESSED FROM SYSDBA.VIRTUALFILESYSTEM WHERE ITEMNAME LIKE '%.entity.xml' "; using (DataSet vfsDataset = newDB.ExecuteWithResults(vfsSql)) { if (vfsDataset.Tables.Count > 0) { DataTable t = vfsDataset.Tables[0]; foreach (DataRow row in t.Rows) { string itemName = (string) row["ITEMNAME"]; string[] arrItemName = itemName.Split(new string[] {"."}, StringSplitOptions.None); //Name.TABLE.entity.xml if (arrItemName.Length > 2) { string entityName = arrItemName[0]; string tableName = arrItemName[1]; Notify(string.Format("Updating entity {0} (Table {1})", entityName, tableName)); try { Table table = null; foreach (Table currTable in newDB.Tables) { if ((String.Compare(currTable.Name, tableName, true) == 0) && (String.Compare(currTable.Owner, "sysdba", true) == 0)) { table = currTable; break; } } if (table != null) { object ItemData = row["ITEMDATA"]; //we expect an array if (ItemData != null) { object strIsCompressed = row["ISCOMPRESSED"]; Boolean bIsCompressed = (strIsCompressed != null) && (string.Compare((string) strIsCompressed, "T", true) == 0); using (var memoryStream = UnpackItemData((byte[]) ItemData, bIsCompressed)) { XmlDocument xmlEntityDocument = new XmlDocument(); memoryStream.Position = 0; xmlEntityDocument.Load(memoryStream); Boolean XmlModified = false; foreach (Column column in table.Columns) { //is this a string derived type? SqlDataType dataType = column.DataType.SqlDataType; if (column.DataType.SqlDataType == SqlDataType.UserDefinedDataType) { UserDefinedDataType colType = newDB.UserDefinedDataTypes[string.Format("[{0}].[{1}]", column.DataType.Schema, column.DataType.Name)]; if (colType == null) colType = newDB.UserDefinedDataTypes[column.DataType.Name]; if (colType != null) { switch (colType.SystemType.ToUpper()) { case "NVARCHAR": { dataType = SqlDataType.NVarChar; break; } case "NCHAR": { dataType = SqlDataType.NChar; break; } case "NTEXT": { dataType = SqlDataType.NText; break; } } } } if ((dataType == SqlDataType.NChar) || (dataType == SqlDataType.NText) || (dataType == SqlDataType.NVarChar) || (dataType == SqlDataType.NVarCharMax) ) { XmlModified |= ModifyEntityColumn(xmlEntityDocument, column.Name); } } if (XmlModified) { //now save it memoryStream.SetLength(0); xmlEntityDocument.Save(memoryStream); memoryStream.Position = 0; byte[] newData = PackItemData(memoryStream, true, ref bIsCompressed); string updateSql = string.Format( "UPDATE sysdba.VIRTUALFILESYSTEM SET ITEMDATA = @DATA, ISCOMPRESSED = @COMPRESSED WHERE VIRTUALFILESYSTEMID = '{0}'", row["VIRTUALFILESYSTEMID"] ); SqlParameter parameter; SqlCommand command = new SqlCommand(updateSql, updateConnection); parameter = command.Parameters.Add("@DATA", SqlDbType.Image); parameter.Value = newData; parameter = command.Parameters.Add("@COMPRESSED", SqlDbType.NVarChar); parameter.Value = bIsCompressed ? "T" : "F"; command.ExecuteNonQuery(); } } } } } catch (Exception e) { ReportException(e); } } } } } } catch (Exception e) { ReportException(e); } GC.Collect(); }