public void Init()
{
if (Project == null)
{
Helper.Notify("当前项目为空，请先通过菜单“项目-项目管理”加载项目", NotificationType.Error);
return;
}
ProjectTemplateViewModel[] models = new ProjectTemplateViewModel[0];
_provider.ExecuteScopedWork(provider =>
{
IDataContract contract = provider.GetRequiredService <IDataContract>();
models = contract.CodeProjectTemplates.Where(m => m.ProjectId == Project.Id).OrderBy(m => m.Template.Order).Select(m => new ProjectTemplateViewModel(_provider)
{
Id = m.Id,
ProjectId = m.ProjectId,
TemplateId = m.TemplateId,
IsLocked = m.IsLocked,
TemplateName = m.Template.Name
}).ToArray();
});
ProjectTemplates.Clear();
foreach (ProjectTemplateViewModel model in models)
{
ProjectTemplates.Add(model);
}
}
public IHttpActionResult PostTemplate(ProjectTemplates template)
{
if (template == null)
{
return(BadRequest("template object must be passed in the request body"));
}
try
{
template.CreatedDate = DateTime.Now;
var templateId = projectTemplatesService.CreateProjectTemplate(template);
var taskId = projectTemplatesService.CreateTemplateTask(new ProjectTemplateTasks()
{
CreatedDate = DateTime.Now,
Description = "Task",
IsActive = true,
IsMileStone = false,
ParentTaskId = null,
TaskCode = "Task",
TaskName = "Task",
TaskDuration = 1,
ShortName = "Task",
TaskTemplateType = 1,
TemplateId = templateId
});
return(Ok(taskId));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
/// <summary>
///Creates a template
/// </summary>
/// <param name="templateRequest"><see cref="ProjectTemplates"/></param>
/// <param name="rawData">The project temaplate file as a byte array.</param>
/// <remarks>
/// This method requires authentication.
/// See the <a href="http://gs2017dev.sdl.com:41234/documentation/api/index#/">API documentation</a> for more information.
/// </remarks>
/// <exception cref="AuthorizationException">
/// Thrown when the current user does not have permission to make the request.
/// </exception>
/// <exception cref="ApiException">Thrown when a general API error occurs.</exception>
/// <returns>Id of created template/></returns>
public async Task <string> CreateTemplate(ProjectTemplates templateRequest, byte[] rawData)
{
var templateId = await ApiConnection.Post <string>(ApiUrls.ProjectTemplates(), templateRequest, "application/json");
await UploadProjectTemplate(templateId, rawData, templateRequest.Name);
return(templateId);
}
public void New()
{
ProjectTemplateViewModel model = IoC.Get <ProjectTemplateViewModel>();
model.ProjectId = Project.Id;
model.TemplateSource = GetTemplates(Project.Id);
ProjectTemplates.Add(model);
}
public NewProjectDialogViewModel() : base("New Project", true, true)
{
shell = IoC.Get <IShell>();
projectTemplates = new ObservableCollection <IProjectTemplate>();
Languages = new List <ILanguageService>(shell.LanguageServices);
location = Platform.ProjectDirectory;
SelectedLanguage = Languages.FirstOrDefault();
SelectedTemplate = ProjectTemplates.FirstOrDefault();
BrowseLocationCommand = ReactiveCommand.Create(async() =>
{
var ofd = new OpenFolderDialog
{
InitialDirectory = location
};
var result = await ofd.ShowAsync();
if (!string.IsNullOrEmpty(result))
{
Location = result;
}
});
OKCommand = ReactiveCommand.Create(async() =>
{
bool generateSolutionDirs = false;
if (solution == null)
{
generateSolutionDirs = true;
var destination = Path.Combine(location, solutionName);
solution = Solution.Create(destination, solutionName, false);
}
if (await selectedTemplate.Generate(solution, name) != null)
{
if (generateSolutionDirs)
{
if (!Directory.Exists(solution.CurrentDirectory))
{
Directory.CreateDirectory(solution.CurrentDirectory);
}
}
}
solution.Save();
shell.CurrentSolution = solution;
solution = null;
Close();
},
this.WhenAny(x => x.Location, x => x.SolutionName, (location, solution) => solution.Value != null && !Directory.Exists(Path.Combine(location.Value, solution.Value))));
}
public static async Task <string> CreateTemplateResourceAsync(string orgId)
{
var id = Guid.NewGuid().ToString();
var templateRequest = new ProjectTemplates(id, $"project template {id}", "", orgId);
var rawData = System.IO.File.ReadAllBytes(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"Resources\SampleTemplate.sdltpl"));
var templateId = await GsClient.Project.CreateTemplate(templateRequest, rawData);
return(templateId);
}
public async Task CreateTemplate()
{
var groupShareClient = await Helper.GetGroupShareClient();
var rawData = File.ReadAllBytes(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"Resources\SampleTemplate.sdltpl"));
var id = Guid.NewGuid().ToString();
var templateRequest = new ProjectTemplates(id, "kit", "", "5bdb10b8-e3a9-41ae-9e66-c154347b8d17");
var templateId = await groupShareClient.Project.CreateTemplate(templateRequest, rawData);
Assert.True(templateId != string.Empty);
await groupShareClient.Project.Delete(templateId);
}
public async Task CreateTemplate()
{
var groupShareClient = Helper.GsClient;
var rawData = File.ReadAllBytes(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"Resources\SampleTemplate.sdltpl"));
var id = Guid.NewGuid().ToString();
var templateName = Guid.NewGuid().ToString();
var templateRequest = new ProjectTemplates(id, templateName, "", Helper.OrganizationId);
var templateId = await groupShareClient.Project.CreateTemplate(templateRequest, rawData);
Assert.True(templateId != string.Empty);
await groupShareClient.Project.Delete(templateId);
}
private async Task <string> CreateProjectTemplateForPerfectMatch(string projectTemplateFilePath)
{
var projectTemplateData = File.ReadAllBytes(projectTemplateFilePath);
var projectTemplateRequest = new ProjectTemplates
{
Id = Guid.NewGuid().ToString(),
Name = "PerfectMatchProjectTemplate_" + Guid.NewGuid().ToString(),
Description = "",
OrganizationId = Helper.OrganizationId
};
var projectTemplateId = await Helper.GsClient.Project.CreateTemplate(projectTemplateRequest, projectTemplateData);
return(projectTemplateId);
}
public void CreateHaloPcTagList()
{
//allocate template-based controls
ProjectTemplate proj = ProjectTemplates.GetTemplate("HaloPCMultiplayer");
m_RootTagControls = new TagTemplateControlSet[proj.TagSet.Length];
for (int i = 0; i < proj.TagSet.Length; i++)
{
m_RootTagControls[i] = new TagTemplateControlSet();
}
//suspend layout of appropriate parent controls
this.SuspendLayout();
this.wizardNewProject2.SuspendLayout();
//do the "BeginInit()" calls for the template-based edit controls
for (int i = 0; i < m_RootTagControls.Length; i++)
{
m_RootTagControls[i].InitLayout();
}
for (int i = 0; i < m_RootTagControls.Length; i++)
{
this.wizardNewProject3.Controls.Add(m_RootTagControls[i].tagFilename);
this.wizardNewProject3.Controls.Add(m_RootTagControls[i].browseButton);
}
for (int i = 0; i < proj.TagSet.Length; i++)
{
m_RootTagControls[i].PerformControlInit(i, proj.TagSet[i].DefaultFile, proj.TagSet[i].Name);
}
for (int i = 0; i < m_RootTagControls.Length; i++)
{
m_RootTagControls[i].EndLayout();
}
this.wizardNewProject2.ResumeLayout(false);
this.ResumeLayout(false);
}
public async void Save()
{
if (!CanSave)
{
Helper.Notify("项目模板验证失败", NotificationType.Warning);
return;
}
CodeProjectTemplateInputDto[] dtos = ProjectTemplates.Select(m => m.MapTo <CodeProjectTemplateInputDto>()).ToArray();
OperationResult result = null;
await _provider.ExecuteScopedWorkAsync(async provider =>
{
IDataContract contract = provider.GetRequiredService <IDataContract>();
result = await contract.UpdateCodeProjectTemplates(dtos);
});
Helper.Notify(result);
if (!result.Succeeded)
{
return;
}
Init();
}
private void btnCreateNewProjectFile_Click(object sender, EventArgs e)
{
SaveFileDialog sfd = new SaveFileDialog();
sfd.Filter = "Prometheus Project File (*.pproj)|*.pproj";
if (sfd.ShowDialog() == DialogResult.Cancel)
{
return;
}
string filename = sfd.FileName;
ProjectFile proj = new ProjectFile("Bloodgulch 2", "MonoxideC", ProjectTemplates.GetTemplate("HaloPCMultiplayer"));
proj.Description = "This is the new 1337 shit baby.";
proj.UiScreenShotFile = "bitchinshot.png";
proj.Tags.Add(new ProjectTag("Scenario", @"levels\test\bloodgulch2\bloodgulch2.scenario"));
proj.Tags.Add(new ProjectTag("Globals", @"globals\globals.globals"));
string xml = proj.SaveToXML();
StreamWriter sw = new StreamWriter(filename);
sw.Write(xml);
sw.Close();
MessageBox.Show("Saved project file to: " + filename);
}
public void EditProjectTemplate(ProjectTemplates template)
{
var original = templatesRepository.GetById(t => t.TemplateId == template.TemplateId);
templatesRepository.Update(original, template.AutoMapObject <ProjectTemplates, DB.ProjectTemplate>());
}
public int CreateProjectTemplate(ProjectTemplates template)
{
var res = templatesRepository.Insert(template.AutoMapObject <Model.Contracts.ProjectTemplates, DB.ProjectTemplate>());
return(res.TemplateId);
}
public int CreateProjectTemplate(ProjectTemplates projectTemplate)
{
var re = projectTemplatesRepository.Insert(projectTemplate.AutoMapObject <ProjectTemplates, DB.ProjectTemplate>());
return(re.TemplateId);
}
public NewProjectDialogViewModel() : base("New Project", true, true)
{
shell = IoC.Get <IShell>();
projectTemplates = new ObservableCollection <ITemplate>();
Languages = new List <ILanguageService>(shell.LanguageServices);
location = Platform.ProjectDirectory;
SelectedLanguage = Languages.FirstOrDefault();
SelectedTemplate = ProjectTemplates.FirstOrDefault();
BrowseLocationCommand = ReactiveCommand.Create(async() =>
{
var ofd = new OpenFolderDialog
{
InitialDirectory = location
};
var result = await ofd.ShowAsync();
if (!string.IsNullOrEmpty(result))
{
Location = result;
}
});
OKCommand = ReactiveCommand.Create(async() =>
{
bool generateSolutionDirs = false;
bool loadNewSolution = false;
if (_solutionFolder == null)
{
loadNewSolution = true;
generateSolutionDirs = true;
var destination = Path.Combine(location, solutionName);
_solutionFolder = VisualStudioSolution.Create(destination, solutionName, false, AvalonStudioSolution.Extension);
}
var templateManager = IoC.Get <TemplateManager>();
var templateDestination = Path.Combine(_solutionFolder.Solution.CurrentDirectory, name);
if (await templateManager.CreateTemplate(selectedTemplate, templateDestination, name) == CreationResult.Success)
{
var projectFiles = GetProjectFiles(templateDestination);
bool defaultSet = _solutionFolder.Solution.StartupProject != null;
foreach (var projectFile in projectFiles)
{
var project = await Project.LoadProjectFileAsync(_solutionFolder.Solution, projectFile);
_solutionFolder.Solution.AddItem(project, _solutionFolder);
if (!defaultSet)
{
defaultSet = true;
_solutionFolder.Solution.StartupProject = project;
}
}
}
_solutionFolder.Solution.Save();
if (loadNewSolution)
{
await shell.OpenSolutionAsync(_solutionFolder.Solution.Location);
}
_solutionFolder = null;
Close();
},
this.WhenAny(x => x.Location, x => x.SolutionName, (location, solution) => solution.Value != null && !Directory.Exists(Path.Combine(location.Value, solution.Value))));
}
private async Task EnsureCreatedCore()
{
var created = await Database.EnsureCreatedAsync();
if (!created)
{
return;
}
var adminUser = await Users.FirstOrDefaultAsync(u => u.Name == "admin", CancellationToken.None);
var userRex = await Users.FirstOrDefaultAsync(u => u.Name == "rex", CancellationToken.None);
var userQuick = await Users.FirstOrDefaultAsync(u => u.Name == "quick", CancellationToken.None);
var userBlocked = await Users.FirstOrDefaultAsync(u => u.Name == "blocked", CancellationToken.None);
adminUser ??= new User
{
Name = "admin",
Password = _passwordHasher.Hash("admin"),
Permissions = Permission.AllPermissions.ToList()
};
userRex ??= new User
{
Name = "rex",
Password = _passwordHasher.Hash("rex"),
Permissions = Role.Editor.ToList()
};
userQuick ??= new User
{
Name = "quick",
Password = _passwordHasher.Hash("quick"),
Permissions = Role.Editor.ToList()
};
userBlocked ??= new User
{
Name = "blocked",
Password = _passwordHasher.Hash("blocked"),
Permissions = Role.BlockedUser.ToList()
};
await Users.AddRangeAsync(adminUser, userRex, userQuick, userBlocked);
await SaveChangesAsync();
ProjectTemplate projectTemplateVanilla5000 = null;
ProjectTemplate projectTemplateVanilla7000 = null;
ProjectTemplate projectTemplateVanilla708711 = null;
projectTemplateVanilla5000 = new ProjectTemplate
{
Name = "Vanilla 5.0.0.0",
ClientVersion = "5.0.0.0",
Location = "D:\\UO\\Vanilla\\5.0.0.0\\5.0.0.0\\Server"
};
projectTemplateVanilla7000 = new ProjectTemplate
{
Name = "Vanilla 7.0.0.0",
ClientVersion = "7.0.0.0",
Location = @"D:\Private\Code\Projects\UOStudio\src\UOStudio.Server.Api\bin\Debug\ProjectTemplates\Vanilla-7.0.0.0\"
};
projectTemplateVanilla708711 = new ProjectTemplate
{
Name = "Vanilla 7.0.87.11",
ClientVersion = "7.0.87.11",
Location = "D:\\UO\\Vanilla\\7.0.87.11\\7.0.87.11\\Server"
};
await ProjectTemplates.AddRangeAsync(projectTemplateVanilla5000, projectTemplateVanilla7000, projectTemplateVanilla708711);
await SaveChangesAsync();
var privateProject5000 = new Project
{
Name = "Private Project 1",
Description = "Some Private Project Rex is working on, based on 5.0.0.0",
IsPublic = false,
Template = projectTemplateVanilla5000,
CreatedBy = userRex,
CreatedAt = DateTimeOffset.Now,
AllowedUsers = new List <User> {
userQuick, userRex
}
};
var privateProject7000 = new Project
{
Name = "Private Project 1",
Description = "Some Private Project Rex is working on, based on 7.0.0.0",
IsPublic = false,
Template = projectTemplateVanilla7000,
CreatedBy = userQuick,
CreatedAt = DateTimeOffset.Now,
AllowedUsers = new List <User> {
userQuick, adminUser
}
};
var publicProject = new Project
{
Name = "Public Project",
Description = "Anybody can join",
IsPublic = true,
Template = projectTemplateVanilla708711,
CreatedBy = adminUser,
CreatedAt = DateTimeOffset.Now,
};
await Projects.AddRangeAsync(privateProject5000, privateProject7000, publicProject);
await SaveChangesAsync();
}
public void AddProjectTemplate(ProjectTemplate pt)
{
ProjectTemplates.Add(pt);
}
public NewProjectDialogViewModel()
: base("New Project", true, true)
{
_studio = IoC.Get <IStudio>();
_templateManager = IoC.Get <TemplateManager>();
_allProjectTemplates = new Lazy <IDictionary <string, IEnumerable <ITemplate> > >(_templateManager.GetProjectTemplates);
location = Platform.ProjectDirectory;
SelectedLanguage = Languages.FirstOrDefault();
SelectedTemplate = ProjectTemplates.FirstOrDefault();
BrowseLocationCommand = ReactiveCommand.Create(async() =>
{
var ofd = new OpenFolderDialog
{
InitialDirectory = location
};
var result = await ofd.ShowAsync();
if (!string.IsNullOrEmpty(result))
{
Location = result;
}
});
OKCommand = ReactiveCommand.Create(async() =>
{
Close();
bool loadNewSolution = false;
if (_solutionFolder == null)
{
IoC.Get <IStatusBar>().SetText("Creating new Solution...");
loadNewSolution = true;
var destination = Path.Combine(location, solutionName);
location = destination;
_solutionFolder = VisualStudioSolution.Create(destination, solutionName, false, VisualStudioSolution.Extension);
}
else
{
IoC.Get <IStatusBar>().SetText("Creating new project...");
}
var templateManager = IoC.Get <TemplateManager>();
var templateDestination = Path.Combine(Location, name);
if (await templateManager.CreateTemplate(selectedTemplate, templateDestination, ("name", name)) == CreationResult.Success)
{
var projectFiles = GetProjectFiles(templateDestination);
bool defaultSet = _solutionFolder.Solution.StartupProject != null;
foreach (var projectFile in projectFiles)
{
var projectTypeGuid = ProjectUtils.GetProjectTypeGuidForProject(projectFile);
if (projectTypeGuid.HasValue)
{
var project = await ProjectUtils.LoadProjectFileAsync(
_solutionFolder.Solution, projectTypeGuid.Value, projectFile);
if (project != null)
{
_solutionFolder.Solution.AddItem(project, projectTypeGuid, _solutionFolder);
}
if (!defaultSet)
{
defaultSet = true;
_solutionFolder.Solution.StartupProject = project;
}
if (!loadNewSolution)
{
await project.LoadFilesAsync();
await project.ResolveReferencesAsync();
}
}
else
{
IoC.Get <Utils.IConsole>().WriteLine(
$"The project '{projectFile}' isn't supported by any installed project type!");
}
}
}
_solutionFolder.Solution.Save();
if (loadNewSolution)
{
await _studio.OpenSolutionAsync(_solutionFolder.Solution.Location);
}
else
{
await _solutionFolder.Solution.RestoreSolutionAsync();
}
_solutionFolder = null;
IoC.Get <IStatusBar>().ClearText();
},
this.WhenAny(x => x.Location, x => x.SolutionName, (location, solution) => solution.Value != null && !Directory.Exists(Path.Combine(location.Value, solution.Value))));
UpdateTemplatesCommand = ReactiveCommand.Create(async() =>
{
var templateManager = IoC.Get <TemplateManager>();
await Task.Run(() =>
{
templateManager.UpdateDefaultTemplates();
_allProjectTemplates = new Lazy <IDictionary <string, IEnumerable <ITemplate> > >(_templateManager.GetProjectTemplates);
SelectedLanguage = SelectedLanguage;
});
});
}
