/// <summary>
/// Handle the 'New package' menu item click
/// </summary>
private void PackageNewPackageMenuItem_Click(object sender, EventArgs e)
{
ToolStripMenuItem menuItem = sender as ToolStripMenuItem;
if (ProjectPackagesTreeView.SelectedNode != null)
{
Mog_BaseTag tag = ProjectPackagesTreeView.SelectedNode.Tag as Mog_BaseTag;
if (tag != null && tag.PackageNodeType == PackageNodeTypes.Class)
{
PackageCreator creator = new PackageCreator();
creator.Classification = ProjectPackagesTreeView.SelectedNode.FullPath;
if (menuItem != null)
{
if (MOG_ControllerProject.IsValidPlatform(menuItem.Text) ||
String.Compare(menuItem.Text, MOG_ControllerProject.GetAllPlatformsString(), true) == 0)
{
creator.Platform = menuItem.Text;
}
}
if (creator.ShowDialog(this) == DialogResult.OK)
{
if (creator.AssetName != null)
{
// Re-create the tree then drill down to the newly created package
ProjectPackagesTreeView.DeInitialize();
ProjectPackagesTreeView.LastNodePath = creator.AssetName.GetAssetClassification() + ProjectPackagesTreeView.PathSeparator + creator.AssetName.GetAssetName();
ProjectPackagesTreeView.Initialize();
}
}
}
}
}
public virtual void CreatePackage(CreatePackageInput input, IFileSystem fileSystem)
{
var manifest = fileSystem.LoadPackageManifestFrom(input.PackageFolder);
var creator = new PackageCreator(fileSystem, new ZipFileService(), new PackageLogger(), new AssemblyFileFinder(new FileSystem()));
creator.CreatePackage(input, manifest);
}
static void Main(string[] args)
{
Assembly asm = Assembly.GetEntryAssembly();
AssemblyName an = asm.GetName();
bool proceed = true;
#if DEBUG
proceed = false;
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("The project was built in DEBUG. Do you want to proceed? [Y/N]");
Console.ForegroundColor = ConsoleColor.Gray;
ConsoleKeyInfo info = Console.ReadKey();
Console.Write(Environment.NewLine);
Console.Write(Environment.NewLine);
if (info.Key == ConsoleKey.Y)
{
proceed = true;
}
#endif
if (proceed)
{
var worker = new PackageCreator(ProductInformation.ApplicationName, an.Version);
worker.ExecuteAsync().Wait();
}
}
private void publishMenuItem_Click(object sender, RoutedEventArgs e)
{
if (string.IsNullOrEmpty(this.projectFile))
{
MessageBox.Show("请先保存工程，然后再发布该应用到速学应用平台!", "记忆工具", MessageBoxButton.OK, MessageBoxImage.Information);
return;
}
try
{
string tempPath = System.IO.Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
tempPath = System.IO.Path.Combine(tempPath, "SlpTemp");
if (!Directory.Exists(tempPath))
{
Directory.CreateDirectory(tempPath);
}
string slpFile = System.IO.Path.Combine(tempPath, this.memorizeEntry.Id + ".slp");
PackageCreator.CreateMrePackage(this.projectFile, slpFile);
installToLocal();
UploadAppWindow uploadAppWindow = new UploadAppWindow(slpFile);
uploadAppWindow.ShowDialog();
// Install to local
// MessageBox.Show("发布成功后，打开速学应用平台在相应的分类学可以使用自己的应用.", "记忆工具", MessageBoxButton.OK, MessageBoxImage.Information);
}
catch
{
MessageBox.Show("发布应用失败，请稍后再试!", "记忆工具", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
public void PackXsltFunction(PackageCreator pc)
{
IXsltFunction xsltFunction;
try
{
xsltFunction = (from i in DataFacade.GetData<IXsltFunction>()
where i.Namespace + "." + i.Name == this.Id
select i).First();
}
catch (Exception)
{
throw new ArgumentException(string.Format(@"XSLT Function '{0}' doesn't exists", this.Id));
}
var newXslFilePath = "\\" + xsltFunction.Namespace.Replace(".", "\\") + "\\" + xsltFunction.Name + ".xsl";
pc.AddFile("App_Data\\Xslt" + xsltFunction.XslFilePath, "App_Data\\Xslt" + newXslFilePath);
xsltFunction.XslFilePath = newXslFilePath;
pc.AddData(xsltFunction);
var parameters = from i in DataFacade.GetData<IParameter>()
where i.OwnerId == xsltFunction.Id
orderby i.Position
select i;
foreach (var parameter in parameters) pc.AddData(parameter);
var namedFunctionCalls = from i in DataFacade.GetData<INamedFunctionCall>()
where i.XsltFunctionId == xsltFunction.Id
orderby i.Name
select i;
foreach (var namedFunctionCall in namedFunctionCalls) pc.AddData(namedFunctionCall);
}
private void PackPageTree(PackageCreator pc, Guid pageId, bool isRoot = false)
{
var page = PageManager.GetPageById(pageId, true);
if (page == null) // Page does not exists in current locale
{
return;
}
foreach (var childPageId in PageManager.GetChildrenIDs(pageId))
{
if (pc.ExcludedIds.Contains(childPageId))
{
continue;
}
PackPageTree(pc, childPageId);
}
foreach (var dataScopeIdentifier in DataFacade.GetSupportedDataScopes(typeof(IPage)))
{
using (new DataScope(dataScopeIdentifier))
{
var pageinScope = PageManager.GetPageById(pageId, true);
if (pageinScope != null)
{
pc.AddData(pageinScope);
pc.AddData <IPagePlaceholderContent>(dataScopeIdentifier, d => d.PageId == pageId);
}
}
}
if (isRoot)
{
using (new DataScope(DataScopeIdentifier.Public))
{
var pageStructure = DataFacade.BuildNew <IPageStructure>();
pageStructure.Id = pageId;
pageStructure.ParentId = Guid.Empty;
pageStructure.LocalOrdering = PageManager.GetLocalOrdering(pageId);
pc.AddData(pageStructure);
}
}
else
{
pc.AddData <IPageStructure>(d => d.Id == pageId);
}
if (IncludeData)
{
pc.AddData <IDataItemTreeAttachmentPoint>(d => d.KeyValue == ValueTypeConverter.Convert <string>(pageId));
pc.AddData <IPageFolderDefinition>(d => d.PageId == pageId);
foreach (Type folderType in page.GetDefinedFolderTypes())
{
pc.AddData(folderType, d => (d as IPageRelatedData).PageId == pageId);
}
}
}
public void GetExcelPackage_ForStoredFile()
{
var packageCreator = new PackageCreator();
var actual = packageCreator.GetExcelPackage();
Assert.Equal(3, actual.Workbook.Worksheets.Count);
}
public void TestCreateTemplateOptions(string displayName, string organization, string expectedDisplayName, string expectedName, string expectedRootNamespace)
{
var options = PackageCreator.CreatePackageTemplateOptions(displayName, organization);
Assert.AreEqual(expectedDisplayName, options.displayName);
Assert.AreEqual(expectedName, options.name);
Assert.AreEqual(expectedRootNamespace, options.rootNamespace);
}
static void Main(string[] args)
{
Assembly asm = Assembly.GetEntryAssembly();
AssemblyName an = asm.GetName();
var worker = new PackageCreator(ProductInformation.ApplicationName, an.Version);
worker.ExecuteAsync().Wait();
}
public ConnectedClient(NetworkStream stream, ServerObject server)
{
this.online = true;
this.stream = stream;
this.server = server;
this.packageCreator = new PackageCreator();
}
public FilePackage(byte[] bytes)
{
List <byte[]> listParsed = PackageCreator.Parse(bytes);
// TODO Создание конструкторов для FilePackage
this.RawData = bytes;
}
void InnerExecute()
{
Directory.CreateDirectory(NuGetsFolder.FullPath());
Directory.CreateDirectory(ChocosFolder.FullPath());
var packageCreator = new PackageCreator(PackagingFolder.FullPath(), NuGetsFolder.FullPath(), ChocosFolder.FullPath(), ProjectName, Version, Log);
packageCreator.CreatePackagesFromNuSpecs();
}
public ServerObject()
{
this.listener = new TcpListener(IPAddress.Any, port);
this.dictionaryConnectedClients = new Dictionary <string, ConnectedClient>();
this.packageCreator = new PackageCreator();
this.dataBase = new WrappedFirebase();
//this.LoadMessageHistory();
}
public DisconnectPackage(byte[] bytes)
{
List <byte[]> listParsed = PackageCreator.Parse(bytes);
this.IdReceiver = PackageCreator.Encoding.GetString(listParsed[0]);
this.IdAuthor = PackageCreator.Encoding.GetString(listParsed[1]);
this.RawData = bytes;
}
public virtual void CreatePackage(CreateBottleInput input, IFileSystem fileSystem)
{
var fileName = FileSystem.Combine(input.PackageFolder, input.ManifestFileNameFlag ?? PackageManifest.FILE);
var manifest = fileSystem.LoadFromFile <PackageManifest>(fileName);
var creator = new PackageCreator(fileSystem, new ZipFileService(fileSystem), new PackageLogger(), new AssemblyFileFinder(fileSystem));
creator.CreatePackage(input, manifest);
}
public HistoryAnswerPackage(string idReceiver, string idAuthor)
{
this.IdReceiver = idReceiver;
this.IdAuthor = idAuthor;
this.RawData = PackageCreator.GetRawFormattedData(
this.Type,
this.IdReceiver,
this.IdAuthor);
}
public void TestCreateTemplateOptions_WithExistingDisplayNameAndNamespace()
{
var options = PackageCreator.CreatePackageTemplateOptions("Package Creator Tests", "Unity");
// Package Creator Tests already exists, it should take Package Creator Tests 1
Assert.AreEqual("Package Creator Tests 1", options.displayName);
Assert.AreEqual("com.unity.packagecreatortests1", options.name);
// Unity.Packageutilitytests1 already exists, it should take Unity.PackageCreatorTests2
Assert.AreEqual("Unity.PackageCreatorTests2", options.rootNamespace);
}
public UsersListAnswerPackage(byte[] bytes)
{
List <byte[]> listParsed = PackageCreator.Parse(bytes);
this.IdReceiver = PackageCreator.Encoding.GetString(listParsed[0]);
this.IdAuthor = PackageCreator.Encoding.GetString(listParsed[1]);
this.Users = PackageCreator.Encoding.GetString(listParsed[2]).Split(separator).ToList();
this.RawData = bytes;
}
public virtual void CreatePackage(CreatePackageInput input, IFileSystem fileSystem)
{
var fileName = FileSystem.Combine(input.PackageFolder, input.ManifestFileNameFlag ?? PackageManifest.FILE);
var reader = new PackageManifestXmlReader();
var manifest = reader.ReadFrom(fileName);
var creator = new PackageCreator(fileSystem, new ZipFileService(fileSystem), new PackageLogger(), new AssemblyFileFinder(new FileSystem()));
creator.CreatePackage(input, manifest);
}
public DisconnectPackage(string idReceiver, string idAuthor)
{
this.IdReceiver = idReceiver;
this.IdAuthor = idAuthor;
this.RawData = PackageCreator.GetRawFormattedData(
this.Type,
this.IdReceiver,
this.IdAuthor);
}
public UsersListRequestPackage(byte[] bytes)
{
List <byte[]> listParsed = PackageCreator.Parse(bytes);
this.IdReceiver = PackageCreator.Encoding.GetString(listParsed[0]);
this.IdAuthor = PackageCreator.Encoding.GetString(listParsed[1]);
this.IdRequest = PackageCreator.Encoding.GetString(listParsed[2]);
this.RawData = bytes;
}
private void SetupAddMenu()
{
AddMenu.menu.AppendAction("Add package from disk...", a =>
{
var path = EditorUtility.OpenFilePanelWithFilters("Select package on disk", "", new[] { "package.json file", "json" });
if (!string.IsNullOrEmpty(path) && !Package.PackageOperationInProgress)
{
Package.AddFromLocalDisk(path);
}
}, a => DropdownMenuAction.Status.Normal);
AddMenu.menu.AppendAction("Add package from git URL...", a =>
{
var addFromGitUrl = new PackagesAction("Add");
addFromGitUrl.actionClicked += url =>
{
addFromGitUrl.Hide();
if (!Package.PackageOperationInProgress)
{
Package.AddFromUrl(url);
}
};
parent.Add(addFromGitUrl);
addFromGitUrl.Show();
}, a => DropdownMenuAction.Status.Normal);
AddMenu.menu.AppendSeparator("");
AddMenu.menu.AppendAction("Create Package...", a =>
{
var defaultName = PackageCreator.GenerateUniquePackageDisplayName("New Package");
var createPackage = new PackagesAction("Create", defaultName);
createPackage.actionClicked += displayName =>
{
createPackage.Hide();
var packagePath = PackageCreator.CreatePackage("Packages/" + displayName);
AssetDatabase.Refresh();
EditorApplication.delayCall += () =>
{
var path = Path.Combine(packagePath, "package.json");
var o = AssetDatabase.LoadMainAssetAtPath(path);
if (o != null)
{
UnityEditor.Selection.activeObject = o;
}
PackageManagerWindow.SelectPackageAndFilter(displayName, PackageFilter.InDevelopment, true);
};
};
parent.Add(createPackage);
createPackage.Show();
}, a => DropdownMenuAction.Status.Normal);
}
private void btnStartSend_Click(object sender, EventArgs e)
{
if (_client == null)
{
_client = ClientsCollection.GetFirstClient();
}
var creator = new PackageCreator(AudioManager.Instance, VideoManager.Instance);
var contentSender = new ContentSenderTls(creator, _client);
_presenter.StartSending(contentSender);
}
public TextPackage(byte[] bytes)
{
List <byte[]> listParsed = PackageCreator.Parse(bytes);
this.IdReceiver = PackageCreator.Encoding.GetString(listParsed[0]);
this.IdAuthor = PackageCreator.Encoding.GetString(listParsed[1]);
this.Time = PackageCreator.ParseTime(listParsed[2]);
this.Content = PackageCreator.Encoding.GetString(listParsed[3]);
this.RawData = bytes;
}
public HistoryRequestPackage(byte[] bytes)
{
List <byte[]> listParsed = PackageCreator.Parse(bytes);
this.IdReceiver = PackageCreator.Encoding.GetString(listParsed[0]);
this.IdAuthor = PackageCreator.Encoding.GetString(listParsed[1]);
this.IdRequest = PackageCreator.Encoding.GetString(listParsed[2]);
this.TimeUntil = PackageCreator.ParseTime(listParsed[3]);
this.RawData = bytes;
}
public HistoryAnswerPackage(byte[] bytes)
{
List <byte[]> listParsed = PackageCreator.Parse(bytes);
this.IdReceiver = PackageCreator.Encoding.GetString(listParsed[0]);
this.IdAuthor = PackageCreator.Encoding.GetString(listParsed[1]);
// TODO Создание конструкторов для HistoryAnswerPackage
this.RawData = bytes;
}
public UsersListAnswerPackage(string idReceiver, string idAuthor, List <string> users)
{
this.IdReceiver = idReceiver;
this.IdAuthor = idAuthor;
this.Users = users.ToList();
this.RawData = PackageCreator.GetRawFormattedData(
this.Type,
this.IdReceiver,
this.IdAuthor,
string.Join(separator, users));
}
public void PackRazorFunction(PackageCreator pc, IFunction function)
{
if (function.EntityToken is FileBasedFunctionEntityToken)
{
var functionEntityToken = (FileBasedFunctionEntityToken)function.EntityToken;
if (functionEntityToken.FunctionProviderName == PackageCreatorFacade.RazorFunctionProviderName)
{
var virtualPath = function.GetProperty("VirtualPath");
pc.AddFile(virtualPath);
}
}
}
public IEnumerator TestCreatePackage()
{
var path = PackageCreator.CreatePackage("Packages/Test Package");
m_FoldersToDelete.Add(path);
// Wait for asset db refresh
yield return(null);
Assert.AreEqual("Packages/com.undefined.testpackage", path);
Assert.IsTrue(Directory.Exists(path));
}
public void Pack(PackageCreator creator)
{
if (Id == _pagesName)
{
#region All Pages
HashSet <Guid> pages;
using (var scope = new DataScope(DataScopeIdentifier.Administrated))
{
pages = DataFacade.GetData <IPage>().Select(p => p.Id).ToHashSet();
}
creator.AddData(typeof(IPage), DataScopeIdentifier.Public, d => pages.Contains((d as IPage).Id));
creator.AddData(typeof(IPage), DataScopeIdentifier.Administrated, d => pages.Contains((d as IPage).Id));
creator.AddData(typeof(IPagePlaceholderContent), DataScopeIdentifier.Public, d => pages.Contains((d as IPagePlaceholderContent).PageId));
creator.AddData(typeof(IPagePlaceholderContent), DataScopeIdentifier.Administrated, d => pages.Contains((d as IPagePlaceholderContent).PageId));
creator.AddData(typeof(IPageStructure), DataScopeIdentifier.Public, d => pages.Contains((d as IPageStructure).Id));
#endregion
}
else if (Id == _mediasName)
{
creator.AddData(typeof(IMediaFileData));
creator.AddData(typeof(IMediaFolderData));
creator.AddFilesInDirectory(@"App_Data\Media\");
}
else if (Id == _datatypesName)
{
IEnumerable <Type> pageDataTypeInterfaces = PageFolderFacade.GetAllFolderTypes();
IEnumerable <Type> pageMetaTypeInterfaces = PageMetaDataFacade.GetAllMetaDataTypes();
foreach (var pageDataType in pageDataTypeInterfaces)
{
creator.AddDataTypeData(pageDataType);
}
foreach (var pageMetaType in pageMetaTypeInterfaces)
{
creator.AddDataTypeData(pageMetaType);
}
}
else if (Id == _applicationsName)
{
creator.AddData <IDataItemTreeAttachmentPoint>();
}
else if (Id == _metatypesName)
{
IEnumerable <Type> pageMetaTypeInterfaces = PageMetaDataFacade.GetAllMetaDataTypes();
foreach (var pageMetaType in pageMetaTypeInterfaces)
{
creator.AddDataTypeData(pageMetaType);
}
}
return;
}
protected void btnExport_Click(object sender, EventArgs e)
{
PackageCreator packageCreator = new PackageCreator();
packageCreator.ExecuteMode = ExecuteMode.FileSystem;
packageCreator.StagingFolder = @"C:\Temp\Drop\Staging";
packageCreator.AutoGeneratePassword = true;
// Generates a dtsx file and return password.
string password = packageCreator.CreateExportToFlatFilePackage(
"MyExcelDtsxPackage", "SELECT [TRequestID], [CorrelationID], [UserName], [StartDate], [EndDate], [RequestStatus], [SubmitDate],[TrainingName] FROM dbo.TrainingRequest", @"Data Source=ENGSOON;Initial Catalog=HRTrainingRequest;User ID=sa;Password=CESoon1012", "MyGeneratedExcelFile", ".csv", "|", true, true);
}
public void Pack(PackageCreator pc)
{
using (new DataScope(DataScopeIdentifier.Administrated))
{
var pageId = new Guid(this.Name);
if (pc.ExcludedIds.Contains(pageId))
{
return;
}
PackPageTree(pc, pageId, IsRoot);
}
}
public void PackInlineFunction(PackageCreator creator)
{
var inlineFunction = DataFacade.GetData<IInlineFunction>(data => (data.Namespace + "." + data.Name) == this.Name).FirstOrDefault();
if (inlineFunction != null)
{
var inlineFunctionId = inlineFunction.Id;
creator.AddData(inlineFunction);
creator.AddData<IInlineFunctionAssemblyReference>(d => d.Function == inlineFunctionId);
creator.AddData<IParameter>(d => d.OwnerId == inlineFunctionId);
creator.AddFile(string.Format(@"App_Data\Composite\InlineCSharpFunctions\{0}", inlineFunction.CodePath));
}
}
public void PackVisualFunction(PackageCreator pc)
{
IVisualFunction visualFunction;
try
{
visualFunction = (from i in DataFacade.GetData<IVisualFunction>()
where i.Namespace + "." + i.Name == this.Id
select i).First();
}
catch (Exception)
{
throw new ArgumentException(string.Format(@"Visual Function '{0}' doesn't exists", this.Id));
}
pc.AddData(visualFunction);
}
public void PackCSharpFunction(PackageCreator pc)
{
IMethodBasedFunctionInfo csharpFunction;
try
{
csharpFunction = (from i in DataFacade.GetData<IMethodBasedFunctionInfo>()
where i.Namespace + "." + i.UserMethodName == this.Id
select i).First();
}
catch (Exception)
{
throw new ArgumentException(string.Format(@"C# Function '{0}' doesn't exists", this.Id));
}
pc.AddData(csharpFunction);
}
public void PackUserControlFunction(PackageCreator pc, IFunction function)
{
if (function.EntityToken is FileBasedFunctionEntityToken)
{
var functionEntityToken = (FileBasedFunctionEntityToken)function.EntityToken;
if (functionEntityToken.FunctionProviderName == PackageCreatorFacade.UserControlFunctionProviderName)
{
var virtualPath = function.GetProperty("VirtualPath");
pc.AddFile(virtualPath);
string codeFile = virtualPath + ".cs";
if (C1File.Exists(PathUtil.Resolve(codeFile)))
{
pc.AddFile(codeFile);
}
}
}
}
public void Pack(PackageCreator creator)
{
var pageType = DataFacade.GetData<IPageType>(d => d.Name == this.Name).FirstOrDefault();
if (pageType == null)
throw new InvalidOperationException(string.Format("PageType '{0}' does not exists", this.Name));
var pageTypeId = pageType.Id;
creator.AddData(pageType);
creator.AddData<IPageTypeDataFolderTypeLink>(d => d.PageTypeId == pageTypeId);
creator.AddData<IPageTypeDefaultPageContent>(d => d.PageTypeId == pageTypeId);
creator.AddData<IPageTypeMetaDataTypeLink>(d => d.PageTypeId == pageTypeId);
creator.AddData<IPageTypePageTemplateRestriction>(d => d.PageTypeId == pageTypeId);
creator.AddData<IPageTypeParentRestriction>(d => d.PageTypeId == pageTypeId);
creator.AddData<IPageTypeTreeLink>(d => d.PageTypeId == pageTypeId);
foreach (var pageMetaDataDefinition in DataFacade.GetData<IPageMetaDataDefinition>(d => d.DefiningItemId == pageTypeId))
{
creator.AddData(pageMetaDataDefinition);
creator.AddData<ICompositionContainer>(d => d.Id == pageMetaDataDefinition.MetaDataContainerId);
}
}
public void Pack(PackageCreator creator)
{
var pageTemplate = PageTemplateFacade.GetPageTemplates().FirstOrDefault(t => t.Title == Id);
if (pageTemplate == null)
throw new InvalidOperationException(string.Format("Template '{0}' does not exists", Id));
if (pageTemplate.GetType().Name.Contains("MasterPagePageTemplateDescriptor"))
{
var codeBehindFilePath = pageTemplate.GetProperty("CodeBehindFilePath");
var filePath = pageTemplate.GetProperty("FilePath");
creator.AddFile("~" + PathUtil.GetWebsitePath(codeBehindFilePath));
creator.AddFile("~" + PathUtil.GetWebsitePath(filePath));
}
else if (pageTemplate.GetType().Name.Contains("RazorPageTemplateDescriptor"))
{
var virtualPath = pageTemplate.GetProperty("VirtualPath");
creator.AddFile(virtualPath);
}
}
public void Pack(PackageCreator pc)
{
IFunction function = null;
if (FunctionFacade.TryGetFunction(out function, this.Id))
{
var innerFunction = function.GetProperty<IFunction>("InnerFunction");
var innerFunctionTypeName = innerFunction.GetType().Name;
switch (innerFunctionTypeName)
{
case "MethodBasedFunction":
PackCSharpFunction(pc);
break;
case "LazyInitializedInlineFunction":
case "InlineFunction":
PackInlineFunction(pc);
break;
case "RazorBasedFunction":
PackRazorFunction(pc, innerFunction);
break;
case "UserControlBasedFunction":
PackUserControlFunction(pc, innerFunction);
break;
case "VisualFunction`1":
PackVisualFunction(pc);
break;
case "XsltXmlFunction":
PackXsltFunction(pc);
break;
}
}
else
{
throw new InvalidOperationException(string.Format("Function '{0}' does not exists", this.Name));
}
}
public void Pack(PackageCreator creator)
{
if (Id == _pagesName)
{
#region All Pages
HashSet<Guid> pages;
using (var scope = new DataScope(DataScopeIdentifier.Administrated))
{
pages = DataFacade.GetData<IPage>().Select(p => p.Id).ToHashSet();
}
creator.AddData(typeof(IPage), DataScopeIdentifier.Public, d => pages.Contains((d as IPage).Id));
creator.AddData(typeof(IPage), DataScopeIdentifier.Administrated, d => pages.Contains((d as IPage).Id));
creator.AddData(typeof(IPagePlaceholderContent), DataScopeIdentifier.Public, d => pages.Contains((d as IPagePlaceholderContent).PageId));
creator.AddData(typeof(IPagePlaceholderContent), DataScopeIdentifier.Administrated, d => pages.Contains((d as IPagePlaceholderContent).PageId));
creator.AddData(typeof(IPageStructure), DataScopeIdentifier.Public, d => pages.Contains((d as IPageStructure).Id));
#endregion
}
else if (Id == _mediasName)
{
creator.AddData(typeof(IMediaFileData));
creator.AddData(typeof(IMediaFolderData));
creator.AddFilesInDirectory(@"App_Data\Media\");
}
else if (Id == _datatypesName)
{
IEnumerable<Type> pageDataTypeInterfaces = PageFolderFacade.GetAllFolderTypes();
IEnumerable<Type> pageMetaTypeInterfaces = PageMetaDataFacade.GetAllMetaDataTypes();
foreach (var pageDataType in pageDataTypeInterfaces)
{
creator.AddDataTypeData(pageDataType);
}
foreach (var pageMetaType in pageMetaTypeInterfaces)
{
creator.AddDataTypeData(pageMetaType);
}
}
else if (Id == _applicationsName)
{
creator.AddData<IDataItemTreeAttachmentPoint>();
}
else if (Id == _metatypesName)
{
IEnumerable<Type> pageMetaTypeInterfaces = PageMetaDataFacade.GetAllMetaDataTypes();
foreach (var pageMetaType in pageMetaTypeInterfaces)
{
creator.AddDataTypeData(pageMetaType);
}
}
return;
}
public void Pack(PackageCreator creator)
{
var path = Path;
Func<IMediaFileData, bool> fileFilter = file => TestFile(file, path) && !creator.ExcludedPaths.Any(p => TestFile(file, p));
Func<IMediaFolderData, bool> folderFilter = folder => TestFolder(folder, path) && !creator.ExcludedPaths.Any(p => TestFolder(folder, p));
creator.AddData(fileFilter);
creator.AddData(folderFilter);
var files = DataFacade.GetData<IMediaFileData>().Where(fileFilter).ToList();
foreach (var mediaFileData in files)
{
creator.AddFileIfExists(@"App_Data\Media\" + mediaFileData.Id);
}
}
public void Pack(PackageCreator creator)
{
creator.AddDirectory(string.Format(@"App_Data\Composite\LanguagePacks\{0}\", this.Id));
}
public void Pack(PackageCreator pc)
{
using (new DataScope(DataScopeIdentifier.Administrated))
{
var pageId = new Guid(this.Name);
if (pc.ExcludedIds.Contains(pageId))
return;
PackPageTree(pc, pageId, IsRoot);
}
}
private void PackPageTree(PackageCreator pc, Guid pageId, bool isRoot = false)
{
var page = PageManager.GetPageById(pageId, true);
if (page == null) // Page does not exists in current locale
return;
foreach (var childPageId in PageManager.GetChildrenIDs(pageId))
{
if (pc.ExcludedIds.Contains(childPageId))
continue;
PackPageTree(pc, childPageId);
}
foreach (var dataScopeIdentifier in DataFacade.GetSupportedDataScopes(typeof(IPage)))
{
using (new DataScope(dataScopeIdentifier))
{
var pageinScope = PageManager.GetPageById(pageId, true);
if (pageinScope != null)
{
pc.AddData(pageinScope);
pc.AddData<IPagePlaceholderContent>(dataScopeIdentifier, d => d.PageId == pageId);
}
}
}
if (isRoot)
{
using (new DataScope(DataScopeIdentifier.Public))
{
var pageStructure = DataFacade.BuildNew<IPageStructure>();
pageStructure.Id = pageId;
pageStructure.ParentId = Guid.Empty;
pageStructure.LocalOrdering = PageManager.GetLocalOrdering(pageId);
pc.AddData(pageStructure);
}
}
else
{
pc.AddData<IPageStructure>(d => d.Id == pageId);
}
if (IncludeData)
{
pc.AddData<IDataItemTreeAttachmentPoint>(d => d.KeyValue == ValueTypeConverter.Convert<string>(pageId));
pc.AddData<IPageFolderDefinition>(d => d.PageId == pageId);
foreach (Type folderType in page.GetDefinedFolderTypes())
{
pc.AddData(folderType, d => (d as IPageRelatedData).PageId == pageId);
}
}
}
public void Init(PackageCreator creator)
{
switch (Type)
{
case Exclude.MediaFolder:
creator.ExcludedPaths.Add(this.Name);
break;
case Exclude.DataItem:
case Exclude.Page:
default:
Guid id;
if (Guid.TryParse(this.Name, out id))
{
creator.ExcludedIds.Add(id);
}
break;
}
}
public void Pack(PackageCreator creator)
{
creator.AddConfigurationXPath(PCCompositeConfig.Source, this.Id);
}
