public async Task <ActionResult <StringResult> > Export([FromBody] ChannelIdsRequest request)
{
if (!await _authManager.HasSitePermissionsAsync(request.SiteId, MenuUtils.SitePermissions.Channels))
{
return(Unauthorized());
}
var site = await _siteRepository.GetAsync(request.SiteId);
if (site == null)
{
return(NotFound());
}
var caching = new CacheUtils(_cacheManager);
var exportObject = new ExportObject(_pathManager, _databaseManager, caching, site);
var fileName = await exportObject.ExportChannelsAsync(request.ChannelIds);
var filePath = _pathManager.GetTemporaryFilesPath(fileName);
var url = _pathManager.GetDownloadApiUrl(filePath);
return(new StringResult
{
Value = url
});
}
public async Task <ActionResult <BoolResult> > SaveData([FromBody] SaveRequest request)
{
if (!await _authManager.HasAppPermissionsAsync(MenuUtils.AppPermissions.SettingsSites))
{
return(Unauthorized());
}
var site = await _siteRepository.GetAsync(request.SiteId);
var siteTemplatePath = _pathManager.GetSiteTemplatesPath(request.TemplateDir);
var siteContentDirectoryPath = _pathManager.GetSiteTemplateMetadataPath(siteTemplatePath, DirectoryUtils.SiteFiles.SiteTemplates.SiteContent);
var caching = new CacheUtils(_cacheManager);
var exportObject = new ExportObject(_pathManager, _databaseManager, caching, site);
await exportObject.ExportSiteContentAsync(siteContentDirectoryPath, request.IsSaveContents, request.IsSaveAllChannels, request.CheckedChannelIds);
await SiteTemplateManager.ExportSiteToSiteTemplateAsync(_pathManager, _databaseManager, caching, site, request.TemplateDir);
var siteTemplateInfo = new SiteTemplateInfo
{
SiteTemplateName = request.TemplateName,
PicFileName = string.Empty,
WebSiteUrl = request.WebSiteUrl,
Description = request.Description
};
var xmlPath = _pathManager.GetSiteTemplateMetadataPath(siteTemplatePath,
DirectoryUtils.SiteFiles.SiteTemplates.FileMetadata);
XmlUtils.SaveAsXml(siteTemplateInfo, xmlPath);
return(new BoolResult
{
Value = true,
});
}
public async Task <ActionResult <StringResult> > Export([FromBody] ChannelRequest request)
{
if (!await _authManager.HasSitePermissionsAsync(request.SiteId,
Types.SitePermissions.SettingsStyleContent))
{
return(Unauthorized());
}
var site = await _siteRepository.GetAsync(request.SiteId);
if (site == null)
{
return(NotFound());
}
var channel = await _channelRepository.GetAsync(request.ChannelId);
var tableName = _channelRepository.GetTableName(site, channel);
var fileName =
await ExportObject.ExportRootSingleTableStyleAsync(_pathManager, _databaseManager, request.SiteId, tableName,
_tableStyleRepository.GetRelatedIdentities(channel));
var filePath = _pathManager.GetTemporaryFilesPath(fileName);
var downloadUrl = _pathManager.GetRootUrlByPath(filePath);
return(new StringResult
{
Value = downloadUrl
});
}
private string ExportTagStyle(int styleId)
{
var styleInfo = DataProvider.TagStyleDao.GetTagStyleInfo(styleId);
var exportObject = new ExportObject(PublishmentSystemId);
return(exportObject.ExportTagStyle(styleInfo));
}
protected void ExportToWord()
{
var data = GetExportedTable(ExportMode.Filtered);
var obj = new ExportObject();
obj.Tables.Add(data);
_wordService.ExportToWord(obj);
}
protected void ExportToExcel()
{
var data = GetExportedTable(ExportMode.Selected);
var obj = new ExportObject();
obj.Tables.Add(data);
_excelService.ExportToExcel(obj);
}
private void ExportToWordInner(List <Header> headers, List <List <string> > data, string fileName)
{
var table = new ExportTable("", headers, data);
var exportObject = new ExportObject();
exportObject.Tables.Add(table);
WordProvider.Generate(exportObject, fileName);
Process.Start(fileName);
}
private bool ExportContentZip(int nodeId, List <int> contentIdArrayList, bool isPeriods, string dateFrom, string dateTo, ETriState checkedState, out string fileName)
{
var nodeInfo = NodeManager.GetNodeInfo(PublishmentSystemId, nodeId);
fileName = $"{nodeInfo.NodeName}.zip";
var filePath = PathUtils.GetTemporaryFilesPath(fileName);
var exportObject = new ExportObject(PublishmentSystemId);
return(exportObject.ExportContents(filePath, nodeId, contentIdArrayList, isPeriods, dateFrom, dateTo, checkedState));
}
private bool ExportContentZip(int channelId, List <int> contentIdArrayList, bool isPeriods, string dateFrom, string dateTo, ETriState checkedState, out string fileName)
{
var nodeInfo = ChannelManager.GetChannelInfo(SiteId, channelId);
fileName = $"{nodeInfo.ChannelName}.zip";
var filePath = PathUtils.GetTemporaryFilesPath(fileName);
var exportObject = new ExportObject(SiteId);
return(exportObject.ExportContents(filePath, channelId, contentIdArrayList, isPeriods, dateFrom, dateTo, checkedState));
}
public async Task <ActionResult> Export()
{
if (!await _authManager.HasAppPermissionsAsync(Types.AppPermissions.SettingsUsers))
{
return(Unauthorized());
}
var fileName = await ExportObject.ExportRootSingleTableStyleAsync(_pathManager, _databaseManager, 0, _userRepository.TableName, _tableStyleRepository.EmptyRelatedIdentities);
var filePath = _pathManager.GetTemporaryFilesPath(fileName);
return(this.Download(filePath));
}
private void ExportToWord()
{
var _wordService = _ServiceLocator.GetInstance <IWordService>();
var obj = new ExportObject();
obj.Tables.Add(FlatsDataContext.GetExportedTable(ExportMode.All));
obj.Tables.Add(RoomsDataContext.GetExportedTable(ExportMode.All));
obj.Tables.Add(PlotsDataContext.GetExportedTable(ExportMode.All));
obj.Tables.Add(HousesDataContext.GetExportedTable(ExportMode.All));
obj.Tables.Add(ResidenceDataContext.GetExportedTable(ExportMode.All));
_wordService.ExportToWord(obj);
}
public static String Pack(String cTABLE_ID, DataTable dtRows, String cRootDir, String cSYSID)
{
List <ExportObject> arKeys = new List <ExportObject>();
DataTable dtFieldConfig = DbManager.QueryData("SELECT FIELD_NAME,ISKEY FROM S_ETL_FIELD WHERE TABLE_ID='" + cTABLE_ID + "'");
for (int j = 0; (dtRows != null) && (j < dtRows.Rows.Count); j++)
{
ExportObject vo = new ExportObject();
vo.TABLE_ID = cTABLE_ID;
vo.SYS_ID = cSYSID;
String cKEY_ID = StringEx.getString(dtRows, 0, "ID").ToUpper();
for (int k = 0; (dtFieldConfig != null) && (k < dtFieldConfig.Rows.Count); k++)
{
String cFieldName = StringEx.getString(dtFieldConfig, k, "FIELD_NAME").ToUpper();
String cFieldValue = StringEx.getString(dtRows, j, cFieldName);
vo.AddFieldValue(cFieldName, Base64.StrToBase64(cFieldValue));
}
String cFileID_List = StringEx.getString(dtRows, 0, "FILES_ID").ToUpper();
if (cFileID_List.Length > 0)
{
String[] File_List = cFileID_List.Split(',');
cFileID_List = "";
for (int i = 0; i < File_List.Length; i++)
{
if (cFileID_List == "")
{
cFileID_List = "'" + File_List[i] + "'";
}
else
{
cFileID_List = cFileID_List + "," + "'" + File_List[i] + "'";
}
}
DataTable dtFiles = DbManager.QueryData("SELECT ID,TEXT,URL FROM S_UPLOAD WHERE ID in (" + cFileID_List + ")");
for (int k = 0; (dtFiles != null) && (k < dtFiles.Rows.Count); k++)
{
String cID = StringEx.getString(dtFiles, k, "ID").ToUpper();
String cText = StringEx.getString(dtFiles, k, "TEXT").ToUpper();
String cUrl = StringEx.getString(dtFiles, k, "URL").ToUpper();
String cFileName = cRootDir + cUrl.Replace("/", "\\");
if (File.Exists(cFileName))
{
vo.AddFileValue(cID, cText, cUrl, Base64.StrToBase64(cFileName));
}
}
}
arKeys.Add(vo);
}
return(JsonLib.ToJSON(arKeys));
}
protected void ExportToWordSelected()
{
if (SelectedEntities == null || SelectedEntities.Count == 0)
{
_MessageService.ShowMessage("Не выбраны объекты", "Ошибка", image: MessageBoxImage.Error);
}
else
{
var data = GetExportedTable(ExportMode.Selected);
var obj = new ExportObject();
obj.Tables.Add(data);
_wordService.ExportToWord(obj);
}
}
public void Load(PortableExecutable portableExecutable)
{
//references to properties of the portableExecutable we are going to load
String FilePath = portableExecutable.FilePath;
String currentDirectory = portableExecutable.directoryPath;
List <string> listOfBranch = portableExecutable.listOfBranch;
List <PortableExecutable> Dependencies = portableExecutable.Dependencies;
List <DependeciesObject> DependencyNames = portableExecutable.DependencyNames;
List <FunctionObject> ExportedFunctions = portableExecutable.ExportedFunctions;
List <ImportFunctionObject> ImportFunctions = portableExecutable.ImportFunctions;
List <HeaderObject> Headers = portableExecutable.Headers;
List <SectionObject> Sections = portableExecutable.Sections;
List <DirectoryObject> Directories = portableExecutable.Directories;
List <string> ImportNames = portableExecutable.ImportNames;
List <string> importMismatchedFiles = portableExecutable.importMismatchedFiles;
List <string> circularDependencyFiles = portableExecutable.circularDependencyFiles;
List <ErrorObject> issues = portableExecutable.issues;
//the PE Header reader to be used
PeHeaderReader reader = new PeHeaderReader(FilePath);
if (Is32bitFile(reader))
{
LoadImports(FilePath, true, ImportFunctions, ImportNames);
LoadExports(FilePath, true, ExportedFunctions);
}
else
{
Service64Proxy.Service64 proxy = new Service64Proxy.Service64();
MyObject obj2 = new MyObject();
MyObject myobject = proxy.Load64Imports(obj2, FilePath, true);
List <ImportFunctionObject> listOfobj = myobject.FunctionObjectList;
foreach (ImportFunctionObject importFunctions in listOfobj)
{
ImportFunctions.Add(importFunctions);
ImportNames.Add(importFunctions.Dependency);
}
ExportObject exportObject = new ExportObject();
ExportObject exports = proxy.Load64Exports(exportObject, FilePath, true);
List <FunctionObject> exportList = exports.ExportFunctionObjectList;
ExportedFunctions.AddRange(exportList);
}
GetHeader(Headers, reader);
GetAssemblyDependencies(FilePath, ImportFunctions, ImportNames);
GetAssemblyExports(FilePath, ExportedFunctions);
GetDirectories(Directories, reader);
GetSections(Sections, reader);
LoadDependencies(ImportNames, Dependencies, currentDirectory, FilePath, reader, listOfBranch, this, ImportFunctions, importMismatchedFiles, circularDependencyFiles, issues);
}
private string ExportGatherRule(List <string> gatherRuleNameArrayList)
{
var docFileName = "GatherRule.xml";
var filePath = PathUtils.GetTemporaryFilesPath(docFileName);
var exportObject = new ExportObject(PublishmentSystemId);
var gatherRuleInfoArrayList = new ArrayList();
foreach (string gatherRuleName in gatherRuleNameArrayList)
{
gatherRuleInfoArrayList.Add(DataProvider.GatherRuleDao.GetGatherRuleInfo(gatherRuleName, PublishmentSystemId));
}
exportObject.ExportGatherRule(filePath, gatherRuleInfoArrayList);
return(docFileName);
}
public async Task <ActionResult <StringResult> > Export([FromBody] SiteRequest request)
{
if (!await _authManager.HasSitePermissionsAsync(request.SiteId,
MenuUtils.SitePermissions.SettingsStyleSite))
{
return(Unauthorized());
}
var fileName = await ExportObject.ExportRootSingleTableStyleAsync(_pathManager, _databaseManager, request.SiteId, _siteRepository.TableName, _tableStyleRepository.GetRelatedIdentities(request.SiteId));
var filePath = _pathManager.GetTemporaryFilesPath(fileName);
var downloadUrl = _pathManager.GetRootUrlByPath(filePath);
return(new StringResult
{
Value = downloadUrl
});
}
public async Task <ActionResult <StringResult> > Export([FromBody] SiteRequest request)
{
if (!await _authManager.HasSitePermissionsAsync(request.SiteId,
Types.SitePermissions.SettingsStyleRelatedField))
{
return(Unauthorized());
}
var fileName = await ExportObject.ExportRelatedFieldListAsync(_pathManager, _databaseManager, request.SiteId);
var filePath = _pathManager.GetTemporaryFilesPath(fileName);
var downloadUrl = _pathManager.GetRootUrlByPath(filePath);
return(new StringResult
{
Value = downloadUrl
});
}
public void ExportToExcel(ExportObject data)
{
System.Globalization.CultureInfo oldCI = System.Threading.Thread.CurrentThread.CurrentCulture;
try
{
System.Threading.Thread.CurrentThread.CurrentCulture = new System.Globalization.CultureInfo("en-US");
ExportToExcelInner(data.Tables[0].Headers, data.Tables[0].Data);
}
catch (Exception e)
{
Log.ErrorException("Не удалось экспортировать в EXCEL", e);
_MessageService.ShowMessage(@"Не удалось экспортировать объявления в Ms Excel", @"Ошибка",
image: MessageBoxImage.Error);
}
finally
{
System.Threading.Thread.CurrentThread.CurrentCulture = oldCI;
}
}
public static async Task ExportSiteToSiteTemplateAsync(IPathManager pathManager, IDatabaseManager databaseManager, CacheUtils caching, Site site, string siteTemplateDir)
{
var exportObject = new ExportObject(pathManager, databaseManager, caching, site);
var siteTemplatePath = pathManager.GetSiteTemplatesPath(siteTemplateDir);
//导出模板
var templateFilePath = pathManager.GetSiteTemplateMetadataPath(siteTemplatePath, DirectoryUtils.SiteFiles.SiteTemplates.FileTemplate);
await exportObject.ExportTemplatesAsync(templateFilePath);
//导出辅助表及样式
var tableDirectoryPath = pathManager.GetSiteTemplateMetadataPath(siteTemplatePath, DirectoryUtils.SiteFiles.SiteTemplates.Table);
await exportObject.ExportTablesAndStylesAsync(tableDirectoryPath);
//导出站点属性以及站点属性表单
var configurationFilePath = pathManager.GetSiteTemplateMetadataPath(siteTemplatePath, DirectoryUtils.SiteFiles.SiteTemplates.FileConfiguration);
await exportObject.ExportConfigurationAsync(configurationFilePath);
//导出关联字段
var relatedFieldDirectoryPath = pathManager.GetSiteTemplateMetadataPath(siteTemplatePath, DirectoryUtils.SiteFiles.SiteTemplates.RelatedField);
await exportObject.ExportRelatedFieldAsync(relatedFieldDirectoryPath);
}
public static void ExportSiteToSiteTemplate(SiteInfo siteInfo, string siteTemplateDir, string adminName)
{
var exportObject = new ExportObject(siteInfo.Id, adminName);
var siteTemplatePath = PathUtility.GetSiteTemplatesPath(siteTemplateDir);
//导出模板
var templateFilePath = PathUtility.GetSiteTemplateMetadataPath(siteTemplatePath, DirectoryUtils.SiteTemplates.FileTemplate);
exportObject.ExportTemplates(templateFilePath);
//导出辅助表及样式
var tableDirectoryPath = PathUtility.GetSiteTemplateMetadataPath(siteTemplatePath, DirectoryUtils.SiteTemplates.Table);
exportObject.ExportTablesAndStyles(tableDirectoryPath);
//导出站点属性以及站点属性表单
var configurationFilePath = PathUtility.GetSiteTemplateMetadataPath(siteTemplatePath, DirectoryUtils.SiteTemplates.FileConfiguration);
exportObject.ExportConfiguration(configurationFilePath);
//导出关联字段
var relatedFieldDirectoryPath = PathUtility.GetSiteTemplateMetadataPath(siteTemplatePath, DirectoryUtils.SiteTemplates.RelatedField);
exportObject.ExportRelatedField(relatedFieldDirectoryPath);
}
public async Task <ActionResult <SaveFilesResult> > SaveFiles([FromBody] SaveRequest request)
{
if (!await _authManager.HasAppPermissionsAsync(Types.AppPermissions.SettingsSites))
{
return(Unauthorized());
}
var site = await _siteRepository.GetAsync(request.SiteId);
var caching = new CacheUtils(_cacheManager);
var exportObject = new ExportObject(_pathManager, _databaseManager, caching, site);
var siteTemplatePath = _pathManager.GetSiteTemplatesPath(request.TemplateDir);
await exportObject.ExportFilesToSiteAsync(siteTemplatePath, request.IsAllFiles, request.CheckedDirectories, request.CheckedFiles, true);
var channel = await _channelRepository.GetAsync(request.SiteId);
channel.Children = await _channelRepository.GetChildrenAsync(request.SiteId, request.SiteId);
return(new SaveFilesResult
{
Channel = channel
});
}
private RmResource ConvertToResource(ExportObject exportObject)
{
var sourceObject = exportObject.ResourceManagementObject;
var resource = new RmResource();
resource.ObjectType = sourceObject.ObjectType;
foreach (var attribute in sourceObject.ResourceManagementAttributes)
{
var rmAttributeName = new RmAttributeName(attribute.AttributeName);
var rmAttributeValue = attribute.IsMultiValue
? (RmAttributeValue) new RmAttributeValueMulti(attribute.Values)
: (RmAttributeValue) new RmAttributeValueSingle(attribute.Value)
;
if (rmAttributeValue.Value is string)
{
string s = (string)rmAttributeValue.Value;
if (s.StartsWith("urn:uuid:"))
{
rmAttributeValue.Value = new RmReference(s);
}
}
if (resource.ContainsKey(rmAttributeName))
{
resource[rmAttributeName] = rmAttributeValue;
}
else
{
resource.Add(rmAttributeName, rmAttributeValue);
}
}
return(resource);
}
public void ExportToWord(ExportObject data)
{
var dlg = new Microsoft.Win32.SaveFileDialog
{
DefaultExt = "rich text format file |*.rtf",
Filter = "rtf file |*.rtf"
};
if (dlg.ShowDialog() == true)
{
string fileName = dlg.FileName;
try
{
WordProvider.Generate(data, fileName);
Process.Start(fileName);
}
catch (Exception e)
{
Log.ErrorException("Не удалось экспортировать в RTF", e);
_MessageService.ShowMessage(@"Не удалось экспортировать объявления в Ms Word", @"Ошибка",
image: MessageBoxImage.Error);
}
}
}
public ExportObject Load64Exports(ExportObject myObject, string filePath, bool mappedAsImage)
{
List <FunctionObject> exportList = myObject.ExportFunctionObjectList;
//var hLib = LoadLibraryEx(filePath, 0,
// DONT_RESOLVE_DLL_REFERENCES | LOAD_IGNORE_CODE_AUTHZ_LEVEL);
var hLib = LoadLibrary(filePath);
unsafe
{
void *hMod = (void *)hLib;
ulong BaseAddress = (ulong)hMod;
if (hMod != null)
{
ulong size;
IMAGE_EXPORT_DIRECTORY *pExportDir = (IMAGE_EXPORT_DIRECTORY *)Interop.ImageDirectoryEntryToData((void *)hLib, true, Interop.IMAGE_DIRECTORY_ENTRY_EXPORT, out size);
if (pExportDir != null)
{
ulong *pFuncNames = (ulong *)(BaseAddress + pExportDir->AddressOfNames);
for (uint i = 0; i < pExportDir->NumberOfNames; i++)
{
ulong funcNameRva = pFuncNames[i];
// ulong funcNameRva = pFuncNames[i];
if (funcNameRva != 0)
{
char *funcName = (char *)(BaseAddress + funcNameRva);
var name = Marshal.PtrToStringAnsi((IntPtr)funcName);
exportList.Add(new FunctionObject(name));
}
}
}
}
}
return(myObject);
}
private RmResource ConvertToResource(ExportObject exportObject)
{
var sourceObject = exportObject.ResourceManagementObject;
var resource = new RmResource();
resource.ObjectType = sourceObject.ObjectType;
foreach (var attribute in sourceObject.ResourceManagementAttributes)
{
var rmAttributeName = new RmAttributeName(attribute.AttributeName);
var rmAttributeValue = attribute.IsMultiValue
? (RmAttributeValue)new RmAttributeValueMulti(attribute.Values)
: (RmAttributeValue)new RmAttributeValueSingle(attribute.Value)
;
if (rmAttributeValue.Value is string)
{
string s = (string)rmAttributeValue.Value;
if (s.StartsWith("urn:uuid:"))
{
rmAttributeValue.Value = new RmReference(s);
}
}
if (resource.ContainsKey(rmAttributeName))
{
resource[rmAttributeName] = rmAttributeValue;
}
else
{
resource.Add(rmAttributeName, rmAttributeValue);
}
}
return resource;
}
public async Task <ActionResult <SubmitResult> > Submit([FromBody] SubmitRequest request)
{
if (!await _authManager.HasContentPermissionsAsync(request.SiteId, request.ChannelId, Types.ContentPermissions.View))
{
return(Unauthorized());
}
var summaries = ContentUtility.ParseSummaries(request.ChannelContentIds);
var site = await _siteRepository.GetAsync(request.SiteId);
if (site == null)
{
return(NotFound());
}
var channel = await _channelRepository.GetAsync(request.ChannelId);
if (channel == null)
{
return(this.Error("无法确定内容对应的栏目"));
}
var columnsManager = new ColumnsManager(_databaseManager, _pathManager);
var columns = await columnsManager.GetContentListColumnsAsync(site, channel, ColumnsManager.PageType.Contents);
var contentInfoList = new List <Content>();
var calculatedContentInfoList = new List <Content>();
if (summaries.Count == 0)
{
var ccIds = await _contentRepository.GetSummariesAsync(site, channel, channel.IsAllContents);
var count = ccIds.Count;
var pages = Convert.ToInt32(Math.Ceiling((double)count / site.PageSize));
if (pages == 0)
{
pages = 1;
}
if (count > 0)
{
for (var page = 1; page <= pages; page++)
{
var offset = site.PageSize * (page - 1);
var limit = site.PageSize;
var pageCcIds = ccIds.Skip(offset).Take(limit).ToList();
var sequence = offset + 1;
foreach (var channelContentId in pageCcIds)
{
var contentInfo = await _contentRepository.GetAsync(site, channelContentId.ChannelId, channelContentId.Id);
if (contentInfo == null)
{
continue;
}
if (!request.IsAllCheckedLevel)
{
var checkedLevel = contentInfo.CheckedLevel;
if (contentInfo.Checked)
{
checkedLevel = site.CheckContentLevel;
}
if (!request.CheckedLevelKeys.Contains(checkedLevel))
{
continue;
}
}
if (!request.IsAllDate)
{
if (contentInfo.AddDate < request.StartDate || contentInfo.AddDate > request.EndDate)
{
continue;
}
}
contentInfoList.Add(contentInfo);
calculatedContentInfoList.Add(await columnsManager.CalculateContentListAsync(sequence++, site, request.ChannelId, contentInfo, columns));
}
}
}
}
else
{
var sequence = 1;
foreach (var channelContentId in summaries)
{
var contentInfo = await _contentRepository.GetAsync(site, channelContentId.ChannelId, channelContentId.Id);
if (contentInfo == null)
{
continue;
}
if (!request.IsAllCheckedLevel)
{
var checkedLevel = contentInfo.CheckedLevel;
if (contentInfo.Checked)
{
checkedLevel = site.CheckContentLevel;
}
if (!request.CheckedLevelKeys.Contains(checkedLevel))
{
continue;
}
}
if (!request.IsAllDate)
{
if (contentInfo.AddDate < request.StartDate || contentInfo.AddDate > request.EndDate)
{
continue;
}
}
contentInfoList.Add(contentInfo);
calculatedContentInfoList.Add(await columnsManager.CalculateContentListAsync(sequence++, site, request.ChannelId, contentInfo, columns));
}
}
var downloadUrl = string.Empty;
if (contentInfoList.Count > 0)
{
if (request.ExportType == "zip")
{
var fileName = $"{channel.ChannelName}.zip";
var filePath = _pathManager.GetTemporaryFilesPath(fileName);
var caching = new CacheUtils(_cacheManager);
var exportObject = new ExportObject(_pathManager, _databaseManager, caching, site);
contentInfoList.Reverse();
if (await exportObject.ExportContentsAsync(filePath, contentInfoList))
{
downloadUrl = _pathManager.GetTemporaryFilesUrl(fileName);
}
}
else if (request.ExportType == "excel")
{
var exportColumnNames =
request.IsAllColumns ? columns.Select(x => x.AttributeName).ToList() : request.ColumnNames;
var fileName = $"{channel.ChannelName}.csv";
var filePath = _pathManager.GetTemporaryFilesPath(fileName);
var excelObject = new ExcelObject(_databaseManager, _pathManager);
await excelObject.CreateExcelFileForContentsAsync(filePath, site, channel, calculatedContentInfoList, exportColumnNames);
downloadUrl = _pathManager.GetTemporaryFilesUrl(fileName);
}
}
return(new SubmitResult
{
Value = downloadUrl,
IsSuccess = !string.IsNullOrEmpty(downloadUrl)
});
}
public IHttpActionResult Submit()
{
try
{
var request = new RequestImpl();
var downloadUrl = string.Empty;
var siteId = request.GetPostInt("siteId");
var channelId = request.GetPostInt("channelId");
var exportType = request.GetPostString("exportType");
var isAllCheckedLevel = request.GetPostBool("isAllCheckedLevel");
var checkedLevelKeys = request.GetPostObject <List <int> >("checkedLevelKeys");
var isAllDate = request.GetPostBool("isAllDate");
var startDate = request.GetPostDateTime("startDate", DateTime.Now);
var endDate = request.GetPostDateTime("endDate", DateTime.Now);
var columnNames = request.GetPostObject <List <string> >("columnNames");
if (!request.IsAdminLoggin ||
!request.AdminPermissions.HasChannelPermissions(siteId, channelId,
ConfigManager.ChannelPermissions.ChannelEdit))
{
return(Unauthorized());
}
var siteInfo = SiteManager.GetSiteInfo(siteId);
if (siteInfo == null)
{
return(BadRequest("无法确定内容对应的站点"));
}
var channelInfo = ChannelManager.GetChannelInfo(siteId, channelId);
if (channelInfo == null)
{
return(BadRequest("无法确定内容对应的栏目"));
}
var columns = ContentManager.GetContentColumns(siteInfo, channelInfo, true);
var pluginIds = PluginContentManager.GetContentPluginIds(channelInfo);
var pluginColumns = PluginContentManager.GetContentColumns(pluginIds);
var contentInfoList = new List <ContentInfo>();
var count = ContentManager.GetCount(siteInfo, channelInfo);
var pages = Convert.ToInt32(Math.Ceiling((double)count / siteInfo.Additional.PageSize));
if (pages == 0)
{
pages = 1;
}
if (count > 0)
{
for (var page = 1; page <= pages; page++)
{
var offset = siteInfo.Additional.PageSize * (page - 1);
var limit = siteInfo.Additional.PageSize;
var pageContentIds = ContentManager.GetContentIdList(siteInfo, channelInfo, offset, limit);
var sequence = offset + 1;
foreach (var contentId in pageContentIds)
{
var contentInfo = ContentManager.GetContentInfo(siteInfo, channelInfo, contentId);
if (contentInfo == null)
{
continue;
}
if (!isAllCheckedLevel)
{
var checkedLevel = contentInfo.CheckedLevel;
if (contentInfo.IsChecked)
{
checkedLevel = siteInfo.Additional.CheckContentLevel;
}
if (!checkedLevelKeys.Contains(checkedLevel))
{
continue;
}
}
if (!isAllDate)
{
if (contentInfo.AddDate < startDate || contentInfo.AddDate > endDate)
{
continue;
}
}
contentInfoList.Add(ContentManager.Calculate(sequence++, contentInfo, columns, pluginColumns));
}
}
if (contentInfoList.Count > 0)
{
if (exportType == "zip")
{
var fileName = $"{channelInfo.ChannelName}.zip";
var filePath = PathUtils.GetTemporaryFilesPath(fileName);
var exportObject = new ExportObject(siteId, request.AdminName);
contentInfoList.Reverse();
if (exportObject.ExportContents(filePath, contentInfoList))
{
downloadUrl = PageUtils.GetTemporaryFilesUrl(fileName);
}
}
else if (exportType == "excel")
{
var fileName = $"{channelInfo.ChannelName}.csv";
var filePath = PathUtils.GetTemporaryFilesPath(fileName);
ExcelObject.CreateExcelFileForContents(filePath, siteInfo, channelInfo, contentInfoList, columnNames);
downloadUrl = PageUtils.GetTemporaryFilesUrl(fileName);
}
}
}
return(Ok(new
{
Value = downloadUrl,
IsSuccess = !string.IsNullOrEmpty(downloadUrl)
}));
}
catch (Exception ex)
{
LogUtils.AddErrorLog(ex);
return(InternalServerError(ex));
}
}
public void Page_Load(object sender, EventArgs e)
{
if (IsForbidden)
{
return;
}
PageUtils.CheckRequestParameter("siteId");
_exportObject = new ExportObject(SiteId, AuthRequest.AdminName);
if (IsPostBack)
{
return;
}
VerifyAdministratorPermissions(ConfigManager.SettingsPermissions.Site);
if (SiteInfo.IsRoot)
{
TbSiteTemplateDir.Text = "T_" + SiteInfo.SiteName;
}
else
{
TbSiteTemplateDir.Text = "T_" + SiteInfo.SiteDir.Replace("\\", "_");
}
TbSiteTemplateName.Text = SiteInfo.SiteName;
EBooleanUtils.AddListItems(RblIsSaveAllFiles, "全部文件", "指定文件");
ControlUtils.SelectSingleItemIgnoreCase(RblIsSaveAllFiles, true.ToString());
var siteDirList = DataProvider.SiteDao.GetLowerSiteDirListThatNotIsRoot();
var fileSystems = FileManager.GetFileSystemInfoExtendCollection(PathUtility.GetSitePath(SiteInfo), true);
foreach (FileSystemInfoExtend fileSystem in fileSystems)
{
if (!fileSystem.IsDirectory)
{
continue;
}
var isSiteDirectory = false;
if (SiteInfo.IsRoot)
{
foreach (var siteDir in siteDirList)
{
if (StringUtils.EqualsIgnoreCase(siteDir, fileSystem.Name))
{
isSiteDirectory = true;
}
}
}
if (!isSiteDirectory && !DirectoryUtils.IsSystemDirectory(fileSystem.Name))
{
CblDirectoriesAndFiles.Items.Add(new ListItem(fileSystem.Name, fileSystem.Name.ToLower()));
}
}
foreach (FileSystemInfoExtend fileSystem in fileSystems)
{
if (fileSystem.IsDirectory || StringUtils.EqualsIgnoreCase(fileSystem.Name, "web.config"))
{
continue;
}
if (!PathUtility.IsSystemFile(fileSystem.Name))
{
CblDirectoriesAndFiles.Items.Add(new ListItem(fileSystem.Name, fileSystem.Name.ToLower()));
}
}
EBooleanUtils.AddListItems(RblIsSaveContents, "保存内容数据", "不保存内容数据");
ControlUtils.SelectSingleItemIgnoreCase(RblIsSaveContents, true.ToString());
EBooleanUtils.AddListItems(RblIsSaveAllChannels, "全部栏目", "指定栏目");
ControlUtils.SelectSingleItemIgnoreCase(RblIsSaveAllChannels, true.ToString());
LtlChannelTree.Text = GetChannelTreeHtml();
}
public ExportObject Load64Exports(ExportObject myObject, string filePath, bool mappedAsImage)
{
return(base.Channel.Load64Exports(myObject, filePath, mappedAsImage));
}
public void Page_Load(object sender, EventArgs e)
{
if (IsForbidden)
{
return;
}
PageUtils.CheckRequestParameter("PublishmentSystemID");
_exportObject = new ExportObject(PublishmentSystemId);
if (IsPostBack)
{
return;
}
BreadCrumbSys(AppManager.Sys.LeftMenu.Site, "保存站点模板", AppManager.Sys.Permission.SysSite);
if (PublishmentSystemInfo.IsHeadquarters)
{
TbSiteTemplateDir.Text = "T_" + PublishmentSystemInfo.PublishmentSystemName;
}
else
{
TbSiteTemplateDir.Text = "T_" + PublishmentSystemInfo.PublishmentSystemDir.Replace("\\", "_");
}
TbSiteTemplateName.Text = PublishmentSystemInfo.PublishmentSystemName;
EBooleanUtils.AddListItems(RblIsSaveAllFiles, "全部文件", "指定文件");
ControlUtils.SelectListItemsIgnoreCase(RblIsSaveAllFiles, true.ToString());
var publishmentSystemDirList = DataProvider.PublishmentSystemDao.GetLowerPublishmentSystemDirListThatNotIsHeadquarters();
var fileSystems = FileManager.GetFileSystemInfoExtendCollection(PathUtility.GetPublishmentSystemPath(PublishmentSystemInfo), true);
foreach (FileSystemInfoExtend fileSystem in fileSystems)
{
if (!fileSystem.IsDirectory)
{
continue;
}
var isPublishmentSystemDirectory = false;
if (PublishmentSystemInfo.IsHeadquarters)
{
foreach (var publishmentSystemDir in publishmentSystemDirList)
{
if (StringUtils.EqualsIgnoreCase(publishmentSystemDir, fileSystem.Name))
{
isPublishmentSystemDirectory = true;
}
}
}
if (!isPublishmentSystemDirectory && !DirectoryUtils.IsSystemDirectory(fileSystem.Name))
{
CblDirectoriesAndFiles.Items.Add(new ListItem(fileSystem.Name, fileSystem.Name.ToLower()));
}
}
foreach (FileSystemInfoExtend fileSystem in fileSystems)
{
if (fileSystem.IsDirectory || StringUtils.EqualsIgnoreCase(fileSystem.Name, "web.config"))
{
continue;
}
if (!PathUtility.IsSystemFile(fileSystem.Name))
{
CblDirectoriesAndFiles.Items.Add(new ListItem(fileSystem.Name, fileSystem.Name.ToLower()));
}
}
EBooleanUtils.AddListItems(RblIsSaveContents, "保存内容数据", "不保存内容数据");
ControlUtils.SelectListItemsIgnoreCase(RblIsSaveContents, true.ToString());
EBooleanUtils.AddListItems(RblIsSaveAllChannels, "全部栏目", "指定栏目");
ControlUtils.SelectListItemsIgnoreCase(RblIsSaveAllChannels, true.ToString());
LtlChannelTree.Text = GetChannelTreeHtml();
SetActivePlaceHolder(WizardPanel.Welcome, PhWelcome);
}
public async Task <string> ExportStylesAsync(int siteId, string tableName, List <int> relatedIdentities)
{
return(await ExportObject.ExportRootSingleTableStyleAsync(this, _databaseManager, siteId, tableName,
relatedIdentities));
}
