/// <summary>
/// 检查是否存在同名文件，若存在则中止程序
/// </summary>
/// <param name="allFilePaths">指定的全部文件</param>
/// <param name="extension">扩展名</param>
public static void CheckSameName(Dictionary <string, List <string> > allFilePaths, string extension)
{
string SameNameFileTemp = null;
foreach (KeyValuePair <string, List <string> > kvp in allFilePaths)
{
if (kvp.Value.Count > 1)
{
SameNameFileTemp = SameNameFileTemp + "\n存在同名" + extension + "文件：" + kvp.Key + "，位置如下：";
foreach (string st in kvp.Value)
{
SameNameFileTemp = SameNameFileTemp + "\n" + st;
}
}
}
//判断是否存在同名文件，若存在则打印出来，退出程序
if (SameNameFileTemp == null)
{
// AppLog.Log(string.Format("Excel同名检查完毕，没有发现同名文件\n"), ConsoleColor.Green);
}
else
{
AppLog.LogError(SameNameFileTemp);
AppLog.LogError("\n存在上面所列同名文件，包含子文件夹都不充许存在同名文件\n");
AppLog.SaveErrorInfoToFile("错误日志");
AppLog.LogErrorAndExit("\n按任意键继续");
}
}
public bool SaveFile(string tableName, string excelName, string sheetName)
{
try
{
if (IsExportKeepDirectoryStructure == true)
{
ExportPath = FileModule.GetExportDirectoryPath(tableName, ExportPath, IsExportKeepDirectoryStructure, false);
}
//如果文件夹不存在就创建
if (Directory.Exists(ExportPath) == false)
{
Directory.CreateDirectory(ExportPath);
}
string s = "";
if (excelName.Contains("-"))
{
s = excelName.Split('-')[1];
}
string fileName2 = string.Concat(excelName + "-" + sheetName, ".", ExportExtension);
string savePath = FileModule.CombinePath(ExportPath, fileName2);
StreamWriter writer = new StreamWriter(savePath, false, new UTF8Encoding(false));
writer.Write(ExportContent);
writer.Flush();
writer.Close();
return(true);
}
catch (Exception e)
{
AppLog.LogErrorAndExit(string.Format("导出失败:{0}", e.ToString()));
return(false);
}
}
public static void GetFileState(Dictionary <string, string> ExportTables)
{
StringBuilder content = new StringBuilder();
string filePath = null;
foreach (KeyValuePair <string, string> kvp in ExportTables)
{
filePath = kvp.Value;
// 检查文件是否存在且没被打开
FileState fileState = GetFileState(filePath);
if (fileState == FileState.Inexist)
{
content.Append(string.Format("{0}文件不存在\n", filePath));
}
else if (fileState == FileState.IsOpen)
{
content.Append(string.Format("{0}文件正在被其他软件打开\n\n", filePath));
}
}
string errorString = content.ToString();
if (errorString.Length > 0)
{
AppLog.LogErrorAndExit(string.Format("错误：存在以下错误，请处理后再执行：\n{0}", errorString));
}
}
private static void CheckExcelPath()
{
//判断指定的Excel文件是否存在
if (!Directory.Exists(ExcelPath))
{
AppLog.LogErrorAndExit(string.Format("错误!!! 输入的Excel表格所在目录不存在，路径为:{0}", ExcelPath));
}
ExcelPath = Path.GetFullPath(ExcelPath);
AppLog.Log(string.Format("提示: 您选择的Excel所在路径：{0}", ExcelPath));
Dictionary <string, List <string> > temp = new Dictionary <string, List <string> >();
SearchOption searchOption;
if (IsIncludeSubfolder == true)
{
searchOption = SearchOption.AllDirectories;
}
else
{
searchOption = SearchOption.TopDirectoryOnly;
}
//获取指定文件夹夹所有Excel文件
AllExcelPaths = FileModule.GetFileInfo(ExcelPath, "xlsx", searchOption);
}
/// <summary>
///
/// </summary>
/// <param name="ExcelName">excel名，如item-道具</param>
/// <returns></returns>
public bool SaveFile(string tableName)
{
try
{
if (IsExportKeepDirectoryStructure == true)
{
ExportPath = FileModule.GetExportDirectoryPath(tableName, ExportPath, IsExportKeepDirectoryStructure, true);
}
//如果文件夹不存在就创建
if (Directory.Exists(ExportPath) == false)
{
Directory.CreateDirectory(ExportPath);
}
string fileName2 = string.Concat(ExportNameBeforeAdd + ExportName + ExportNameAfterLanguageMark, ".", ExportExtension);
string savePath = FileModule.CombinePath(ExportPath, fileName2);
StreamWriter writer = new StreamWriter(savePath, false, new UTF8Encoding(false));
writer.Write(ExportContent);
writer.Flush();
writer.Close();
return(true);
}
catch (Exception e)
{
AppLog.LogErrorAndExit(string.Format("导出失败:{0}", e.ToString()));
return(false);
}
}
public static void ExportToTxt(TableInfo tableInfo)
{
string errorString = null;
if (AppValues.MergeTableList.ContainsKey(tableInfo.TableName))
{
TableExportToTxtHelper.ExportTableToTxt2(tableInfo, out errorString);
if (errorString != null)
{
AppLog.LogErrorAndExit(errorString);
}
else
{
AppLog.Log("合并表导出txt成功");
}
return;
}
// 对表格按默认方式导出
if (TableAnalyzeHelper.GetOneConfigData(tableInfo, TxtStruct.Excel_Config_ExportTxt, ref TxtStruct.IsExportTxt))
{
// 对表格按默认方式导出
if (TxtStruct.IsExportTxt == true)
{
TableExportToTxtHelper.ExportTableToTxt(tableInfo, out errorString);
if (errorString != null)
{
AppLog.LogErrorAndExit(errorString);
}
else
{
AppLog.Log("按默认方式导出txt成功");
}
}
}
else
{
// 对表格按默认方式导出
if (TxtStruct.IsExport == true)
{
TableExportToTxtHelper.ExportTableToTxt(tableInfo, out errorString);
if (errorString != null)
{
AppLog.LogErrorAndExit(errorString);
}
else
{
AppLog.Log("按默认方式导出txt成功");
}
}
}
}
public static void ReadLangData()
{
if (IsLang)
{
GetParamValue();
string errorString = null;
LangData = TxtConfigReader.ParseTxtConfigFile(LangPath, ":", out errorString);
if (!string.IsNullOrEmpty(errorString))
{
AppLog.LogErrorAndExit(errorString);
}
}
}
public static void ExportToLuaFile(TableInfo tableInfo)
{
string errorString = null;
TableExportToLuaFileHelper.ExportTableToLuaFile(tableInfo, out errorString);
if (errorString != null)
{
AppLog.LogErrorAndExit(errorString);
}
else
{
AppLog.Log("按默认方式导出LuaFile成功");
}
}
private static void GetParamValue()
{
if (AppValues.BatParamInfo.ContainsKey(ReadParam))
{
Dictionary <string, BatChildParam> ChildParam = AppValues.BatParamInfo[ReadParam].ChildParam;
ExcelPath = BatMethods.GetStringValue(ExcelPath, ChildParam, ExcelPathParam);
IsIncludeSubfolder = BatMethods.GetBoolValue(IsIncludeSubfolder, ChildParam, IsIncludeSubfolderParam);
TheLanguage = BatMethods.GetStringValue(TheLanguage, ChildParam, TheLanguageParam);
IsNeedCheck = BatMethods.GetBoolValue(IsNeedCheck, ChildParam, IsNeedCheckParam);
IsAllowedNullNumber = BatMethods.GetBoolValue(IsAllowedNullNumber, ChildParam, IsAllowedNullNumberParam);
}
if (AppLanguage.AppConfigIDArr == null && TheLanguage != "")
{
AppLog.LogErrorAndExit(string.Format("多语言配置错误:在Bat只设置了{0}({1}={2})，则必须在config.txt中设置{3}:{4}，格式如：MoreLanguage:_ft,_English", ReadParam, TheLanguageParam, TheLanguage, AppLanguage.AppConfigIDArrParam, TheLanguage));
}
}
private static string _GetTimeValue(FieldInfo fieldInfo, int row, int level)
{
StringBuilder content = new StringBuilder();
TimeFormatType timeFormatType = TableAnalyzeHelper.GetTimeFormatType(fieldInfo.ExtraParam[LuaStruct.TimeToExportFormatKey].ToString());
switch (timeFormatType)
{
case TimeFormatType.FormatString:
{
if (fieldInfo.Data[row] == null)
{
content.Append("nil");
}
else
{
content.Append("\"").Append(((DateTime)(fieldInfo.Data[row])).ToString(fieldInfo.ExtraParam[LuaStruct.TimeToExportFormatKey].ToString())).Append("\"");
}
break;
}
case TimeFormatType.ReferenceTimeSec:
{
if (fieldInfo.Data[row] == null)
{
content.Append("nil");
}
else
{
content.Append(((DateTime)(fieldInfo.Data[row]) - DateTimeValue.REFERENCE_DATE).TotalSeconds);
}
break;
}
default:
{
AppLog.LogErrorAndExit("错误：用_GetTimeValue函数导出lua文件的time型的TimeFormatType非法");
break;
}
}
return(content.ToString());
}
/// <summary>
/// 将翻译后的字典读取文件中
/// </summary>
public static void GetLanguageDictData()
{
if (ExcelFolder.TheLanguage != "")
{
string errorString = null;
string MoreLanguagePath = FileModule.CombinePath(AppDomain.CurrentDomain.SetupInformation.ApplicationBase, "Language");;
string TheLanguageDicPath = FileModule.CombinePath(MoreLanguagePath, "Language" + ExcelFolder.TheLanguage);
string TheLanguageDicFile = FileModule.CombinePath(TheLanguageDicPath, ExcelFolder.TheLanguage + "_dict.txt");
if (!File.Exists(TheLanguageDicFile))
{
return;
}
LanguageDictData = TxtConfigReader.ParseTxtConfigFile(TheLanguageDicFile, "\t", out errorString);
if (!string.IsNullOrEmpty(errorString))
{
AppLog.LogErrorAndExit(errorString);
}
}
}
public static void ExportToHrl(TableInfo tableInfo)
{
string errorString = null;
// 对表格按默认方式导出
if (TableAnalyzeHelper.GetOneConfigData(tableInfo, HrlStruct.Excel_Config_ExportHrl, ref HrlStruct.IsExportHrl))
{
// 对表格按默认方式导出
if (HrlStruct.IsExportHrl == true)
{
TableAnalyzeHelper.GetOneConfigData(tableInfo, HrlStruct.Excel_Config_HrlTopInfo, ref HrlStruct.HrlTopInfo);
TableAnalyzeHelper.GetOneConfigData(tableInfo, HrlStruct.Excel_Config_HrlEndInfo, ref HrlStruct.HrlEndInfo);
TableExportToHrlHelper.ExportTableToHrl(tableInfo, out errorString);
if (errorString != null)
{
AppLog.LogErrorAndExit(errorString);
}
else
{
AppLog.Log("按默认方式导出Hrl成功");
}
}
}
else
{
// 对表格按默认方式导出
if (HrlStruct.IsExport == true)
{
TableExportToHrlHelper.ExportTableToHrl(tableInfo, out errorString);
if (errorString != null)
{
AppLog.LogErrorAndExit(errorString);
}
else
{
AppLog.Log("按默认方式导出Hrl成功");
}
}
}
}
public static void CheckTable()
{
if (ExcelFolder.IsNeedCheck == true)
{
string errorString;
foreach (KeyValuePair <string, TableInfo> kvp in AppValues.TableInfo)
{
//合并过的表不再检查
if (AppValues.MergeTableList != null)
{
if (AppValues.MergeTableList.ContainsKey(kvp.Key))
{
continue;
}
}
TableInfo tableInfo = kvp.Value;
AppLog.Log(string.Format("\n检查表格\"{0}\"：", tableInfo.ExcelNameTips), ConsoleColor.Green);
errorString = null;
TableCheckHelper.CheckTable(tableInfo, out errorString);
if (errorString != null)
{
AppLog.LogError(string.Format("检查完成，存在以下错误：\n{0}", errorString));
}
else
{
AppLog.Log("检查完成，正确");
}
if (AppLog.LogErrorContent.Length > 0)
{
AppLog.SaveErrorInfoToFile("错误日志.txt");
AppLog.LogErrorAndExit("\n按任意键继续");
}
}
}
}
/// <summary>
/// 对本地或远程进程进行访问，以及启动或停止本地进程。
/// </summary>
/// <param name="filePath">exe路径</param>
/// <param name="command">exe命令参数</param>
/// <param name="workPath">工作路径</param>
/// <param name="seconds">等待进程等待时间，0无限等待，其他毫秒</param>
public static void ExecuteProcess(string filePath, string command, string workPath = "", int seconds = 0)
{
if (string.IsNullOrEmpty(filePath))
{
return;
}
Process process = new Process();//创建进程对象
process.StartInfo.WorkingDirectory = workPath;
process.StartInfo.FileName = filePath;
process.StartInfo.Arguments = command;
process.StartInfo.CreateNoWindow = true;
process.StartInfo.RedirectStandardOutput = false;//不重定向输出
try
{
if (process.Start())
{
if (seconds == 0)
{
process.WaitForExit(); //无限等待进程结束
}
else
{
process.WaitForExit(seconds); //等待毫秒
}
}
}
catch (Exception e)
{
AppLog.LogErrorAndExit(e.Message);
}
finally
{
process.Close();
}
}
private static string _GetDateValue(FieldInfo fieldInfo, int row, int level)
{
StringBuilder content = new StringBuilder();
DateFormatType dateFormatType = TableAnalyzeHelper.GetDateFormatType(fieldInfo.ExtraParam[LuaStruct.DateToExportFormatKey].ToString());
switch (dateFormatType)
{
case DateFormatType.FormatString:
{
if (fieldInfo.Data[row] == null)
{
content.Append("nil");
}
else
{
content.Append("\"").Append(((DateTime)(fieldInfo.Data[row])).ToString(fieldInfo.ExtraParam[LuaStruct.DateToExportFormatKey].ToString())).Append("\"");
}
break;
}
case DateFormatType.ReferenceDateSec:
{
if (fieldInfo.Data[row] == null)
{
content.Append("nil");
}
else
{
content.Append(((DateTime)(fieldInfo.Data[row]) - DateTimeValue.REFERENCE_DATE).TotalSeconds);
}
break;
}
case DateFormatType.ReferenceDateMsec:
{
if (fieldInfo.Data[row] == null)
{
content.Append("nil");
}
else
{
content.Append(((DateTime)(fieldInfo.Data[row]) - DateTimeValue.REFERENCE_DATE).TotalMilliseconds);
}
break;
}
case DateFormatType.DataTable:
{
if (fieldInfo.Data[row] == null)
{
content.Append("nil");
}
else
{
double totalSeconds = ((DateTime)(fieldInfo.Data[row]) - DateTimeValue.REFERENCE_DATE).TotalSeconds;
content.Append("os.date(\"!*t\", ").Append(totalSeconds).Append(")");
}
break;
}
default:
{
AppLog.LogErrorAndExit("错误：用_GetDateValue函数导出lua文件的date型的DateFormatType非法");
break;
}
}
return(content.ToString());
}
public static void ReadConfig()
{
GetParamValue();
if (File.Exists(AppConfig.ConfigPath))
{
string errorString = null;
AppValues.ConfigData = TxtConfigReader.ParseTxtConfigFile(AppConfig.ConfigPath, ":", out errorString);
if (!string.IsNullOrEmpty(errorString))
{
AppLog.LogErrorAndExit(errorString);
}
}
else
{
AppLog.LogWarning(string.Format("警告：找不到本工具所在路径下的{0}配置文件，请确定是否真的不需要自定义配置", AppConfig.ConfigPath));
}
//检查datetime类型，并初始化
// 读取部分配置项并进行检查
const string ERROR_STRING_FORMAT = "配置项\"{0}\"所设置的值\"{1}\"非法：{2}\n";
StringBuilder errorStringBuilder = new StringBuilder();
string tempErrorString = null;
if (AppValues.ConfigData.ContainsKey(DateTimeValue.APP_CONFIG_KEY_DEFAULT_DATE_INPUT_FORMAT))
{
DateTimeValue.DefaultDateInputFormat = AppValues.ConfigData[DateTimeValue.APP_CONFIG_KEY_DEFAULT_DATE_INPUT_FORMAT].Trim();
if (TableCheckHelper.CheckDateInputDefine(DateTimeValue.DefaultDateInputFormat, out tempErrorString) == false)
{
errorStringBuilder.AppendFormat(ERROR_STRING_FORMAT, DateTimeValue.APP_CONFIG_KEY_DEFAULT_DATE_INPUT_FORMAT, DateTimeValue.DefaultDateInputFormat, tempErrorString);
}
}
if (AppValues.ConfigData.ContainsKey(DateTimeValue.APP_CONFIG_KEY_DEFAULT_TIME_INPUT_FORMAT))
{
DateTimeValue.DefaultTimeInputFormat = AppValues.ConfigData[DateTimeValue.APP_CONFIG_KEY_DEFAULT_TIME_INPUT_FORMAT].Trim();
if (TableCheckHelper.CheckTimeDefine(DateTimeValue.DefaultTimeInputFormat, out tempErrorString) == false)
{
errorStringBuilder.AppendFormat(ERROR_STRING_FORMAT, DateTimeValue.APP_CONFIG_KEY_DEFAULT_TIME_INPUT_FORMAT, DateTimeValue.DefaultTimeInputFormat, tempErrorString);
}
}
//if (AppValues.ConfigData.ContainsKey(DateTimeValue.APP_CONFIG_KEY_DEFAULT_DATE_INPUT_FORMAT))
//{
// DateTimeValue.DefaultDateInputFormat = AppValues.ConfigData[DateTimeValue.APP_CONFIG_KEY_DEFAULT_DATE_INPUT_FORMAT].Trim();
// if (TableCheckHelper.CheckDateInputDefine(DateTimeValue.DefaultDateInputFormat, out tempErrorString) == false)
// errorStringBuilder.AppendFormat(ERROR_STRING_FORMAT, DateTimeValue.APP_CONFIG_KEY_DEFAULT_DATE_INPUT_FORMAT, DateTimeValue.DefaultDateInputFormat, tempErrorString);
//}
//if (AppValues.ConfigData.ContainsKey(LuaStruct.DefaultDateToExportFormatKey))
//{
// LuaStruct.DefaultDateToExportFormat = AppValues.ConfigData[LuaStruct.DefaultDateToExportFormatKey].Trim();
// if (TableCheckHelper.CheckDateToLuaDefine(LuaStruct.DefaultDateToExportFormat, out tempErrorString) == false)
// errorStringBuilder.AppendFormat(ERROR_STRING_FORMAT, LuaStruct.DefaultDateToExportFormatKey, LuaStruct.DefaultDateToExportFormat, tempErrorString);
//}
//if (AppValues.ConfigData.ContainsKey(MySQLStruct.DefaultDateToExportFormatKey))
//{
// MySQLStruct.DefaultDateToExportFormat = AppValues.ConfigData[MySQLStruct.DefaultDateToExportFormatKey].Trim();
// if (TableCheckHelper.CheckDateToDatabaseDefine(MySQLStruct.DefaultDateToExportFormat, out tempErrorString) == false)
// errorStringBuilder.AppendFormat(ERROR_STRING_FORMAT, MySQLStruct.DefaultDateToExportFormatKey, MySQLStruct.DefaultDateToExportFormat, tempErrorString);
//}
//if (AppValues.ConfigData.ContainsKey(DateTimeValue.APP_CONFIG_KEY_DEFAULT_TIME_INPUT_FORMAT))
//{
// DateTimeValue.DefaultTimeInputFormat = AppValues.ConfigData[DateTimeValue.APP_CONFIG_KEY_DEFAULT_TIME_INPUT_FORMAT].Trim();
// if (TableCheckHelper.CheckTimeDefine(DateTimeValue.DefaultTimeInputFormat, out tempErrorString) == false)
// errorStringBuilder.AppendFormat(ERROR_STRING_FORMAT, DateTimeValue.APP_CONFIG_KEY_DEFAULT_TIME_INPUT_FORMAT, DateTimeValue.DefaultTimeInputFormat, tempErrorString);
//}
//if (AppValues.ConfigData.ContainsKey(LuaStruct.DefaultTimeToExportFormatKey))
//{
// LuaStruct.DefaultTimeToExportFormat = AppValues.ConfigData[LuaStruct.DefaultTimeToExportFormatKey].Trim();
// if (TableCheckHelper.CheckTimeDefine(LuaStruct.DefaultTimeToExportFormat, out tempErrorString) == false)
// errorStringBuilder.AppendFormat(ERROR_STRING_FORMAT, LuaStruct.DefaultTimeToExportFormatKey, LuaStruct.DefaultTimeToExportFormat, tempErrorString);
//}
//if (AppValues.ConfigData.ContainsKey(MySQLStruct.DefaultTimeToExportFormatKey))
//{
// MySQLStruct.DefaultTimeToExportFormat = AppValues.ConfigData[MySQLStruct.DefaultTimeToExportFormatKey].Trim();
// if (TableCheckHelper.CheckTimeDefine(MySQLStruct.DefaultTimeToExportFormat, out tempErrorString) == false)
// errorStringBuilder.AppendFormat(ERROR_STRING_FORMAT, MySQLStruct.DefaultTimeToExportFormatKey, MySQLStruct.DefaultTimeToExportFormat, tempErrorString);
//}
string errorConfigString = errorStringBuilder.ToString();
if (!string.IsNullOrEmpty(errorConfigString))
{
errorConfigString = string.Concat("配置文件中存在以下错误，请修正后重试\n", errorConfigString);
AppLog.LogErrorAndExit(errorConfigString);
}
}
/// <summary>
/// 按指定索引方式导出数据时,通过此函数递归生成层次结构,当递归到最内层时输出指定table value中的数据
/// </summary>
private static void _GetIndexFieldData(StringBuilder content, Dictionary <object, object> parentDict, List <FieldInfo> tableValueField, ref int currentLevel, out string errorString)
{
string oneTableValueFieldData = null;
foreach (var key in parentDict.Keys)
{
/*加上这2句大文件卡死*/
//if (content.ToString().EndsWith("}"))
// content.Remove(content.Length - 1, 1).Append(",");
// content.Append(_GetJsonIndentation(currentLevel));
// 生成key
//if(key==null | key.ToString()=="")
//{
// errorString = "错误：嵌套导出的key不能为空！";
// AppLog.LogErrorAndExit(errorString);
// return;
//}
if (key.GetType() == typeof(int) || key.GetType() == typeof(long) || key.GetType() == typeof(float))
{
content.Append("\"").Append(key).Append("\"");
}
else if (key.GetType() == typeof(string))
{
//// 检查作为key值的变量名是否合法
//TableCheckHelper.CheckFieldName(key.ToString(), out errorString);
//if (errorString != null)
//{
// errorString = string.Format("作为第{0}层索引的key值不是合法的变量名，你填写的为\"{1}\"", currentLevel - 1, key.ToString());
// return;
//}
//content.Append(key);
content.Append("\"").Append(key).Append("\"");
}
else
{
errorString = string.Format("SpecialExportTableToJson中出现非法类型的索引列类型{0}", key.GetType());
AppLog.LogErrorAndExit(errorString);
return;
}
content.Append(":{");// content.AppendLine(":{");
++currentLevel;
// 如果已是最内层，输出指定table value中的数据
if (parentDict[key].GetType() == typeof(int))
{
foreach (FieldInfo fieldInfo in tableValueField)
{
int rowIndex = (int)parentDict[key];
oneTableValueFieldData = _GetOneField(fieldInfo, rowIndex, out errorString);//
if (errorString != null)
{
errorString = string.Format("第{0}行的字段\"{1}\"（列号：{2}）导出数据错误：{3}", rowIndex + ExcelTableSetting.DataFieldDataStartRowIndex + 1, fieldInfo.FieldName, ExcelMethods.GetExcelColumnName(fieldInfo.ColumnSeq + 1), errorString);
return;
}
else
{
if (oneTableValueFieldData == null)
{
errorString = string.Format("第{0}行的字段\"{1}\"（列号：{2}）导出数据错误：{3}", rowIndex + ExcelTableSetting.DataFieldDataStartRowIndex + 1, fieldInfo.FieldName, ExcelMethods.GetExcelColumnName(fieldInfo.ColumnSeq + 1), "嵌套导出的值不能为空");
//AppLog.LogErrorAndExit(errorString);
//return;
content.Append("\"").Append(fieldInfo.FieldName).Append("\"");
content.Append(":");
switch (fieldInfo.DataType)
{
case DataType.Int:
case DataType.Long:
case DataType.Float:
{
content.Append("0").Append(",");
break;
}
case DataType.String:
{
content.Append("\"\"").Append(",");
break;
}
case DataType.Bool:
{
content.Append("false").Append(",");
break;
}
case DataType.Lang:
case DataType.Date:
case DataType.Time:
default:
{
content.Append("\"\"").Append(",");
break;
}
}
}
else
{
content.Append(oneTableValueFieldData);
}
}
}
// 去掉最后一个子元素后多余的英文逗号
if (content.ToString().EndsWith(","))
{
content.Remove(content.Length - 1, 1);
}
}
// 否则继续递归生成索引key
else
{
// if (content.ToString().EndsWith("}"))
// content.Remove(content.Length - 1, 1).Append(",");
_GetIndexFieldData(content, (Dictionary <object, object>)(parentDict[key]), tableValueField, ref currentLevel, out errorString);
if (errorString != null)
{
return;
}
if (content.ToString().EndsWith(","))
{
content.Remove(content.Length - 1, 1);
}
//content.Append(",");
}
--currentLevel;
// content.Append(_GetJsonIndentation(currentLevel));
content.Append("},"); // content.AppendLine("},");
}
errorString = null;
}
public static bool ExportTableToLua(TableInfo tableInfo, out string errorString)
{
StringBuilder content = new StringBuilder();
// 生成数据内容开头
if (LuaStruct.IsTableNameStart)
{
content.Append(tableInfo.TableName).AppendLine(" = {");
}
else
{
content.AppendLine("return {");
}
// 当前缩进量
int currentLevel = 1;
// 判断是否设置要将主键列的值作为导出的table中的元素
bool isAddKeyToLuaTable = tableInfo.TableConfigData2 != null && tableInfo.TableConfigData2.ContainsKey(LuaStruct.Excel_Config_AddKeyToLuaTable) && tableInfo.TableConfigData2[LuaStruct.Excel_Config_AddKeyToLuaTable].Count > 0 && "true".Equals(tableInfo.TableConfigData2[LuaStruct.Excel_Config_AddKeyToLuaTable][0], StringComparison.CurrentCultureIgnoreCase);
// 逐行读取表格内容生成lua table
List <FieldInfo> allField = tableInfo.GetAllClientFieldInfo();
int dataCount = tableInfo.GetKeyColumnFieldInfo().Data.Count;
for (int row = 0; row < dataCount; ++row)
{
// 将主键列作为key生成
content.Append(_GetLuaIndentation(currentLevel));
FieldInfo keyColumnField = allField[0];
if (keyColumnField.DataType == DataType.Int || keyColumnField.DataType == DataType.Long)
{
content.AppendFormat("[{0}]", keyColumnField.Data[row]);
}
// 注意：像“1_2”这样的字符串作为table的key必须加[""]否则lua认为是语法错误
else if (keyColumnField.DataType == DataType.String)
{
content.AppendFormat("[\"{0}\"]", keyColumnField.Data[row]);
}
else
{
errorString = "用ExportTableToLua导出不支持的主键列数据类型";
AppLog.LogErrorAndExit(errorString);
return(false);
}
content.AppendLine(" = {");
++currentLevel;
// 如果设置了要将主键列的值作为导出的table中的元素
if (isAddKeyToLuaTable == true)
{
content.Append(_GetLuaIndentation(currentLevel));
content.Append(keyColumnField.FieldName);
content.Append(" = ");
if (keyColumnField.DataType == DataType.Int || keyColumnField.DataType == DataType.Long)
{
content.Append(keyColumnField.Data[row]);
}
else if (keyColumnField.DataType == DataType.String)
{
content.AppendFormat("\"{0}\"", keyColumnField.Data[row]);
}
content.AppendLine(",");
}
// 将其他列依次作为value生成
for (int column = 1; column < allField.Count; ++column)
{
string oneFieldString = _GetOneField(allField[column], row, currentLevel, out errorString);
if (errorString != null)
{
errorString = string.Format("导出表格{0}失败，", tableInfo.TableName) + errorString;
return(false);
}
else
{
content.Append(oneFieldString);
}
}
// 一行数据生成完毕后添加右括号结尾等
--currentLevel;
content.Append(_GetLuaIndentation(currentLevel));
content.AppendLine("},");
}
// 生成数据内容结尾
content.AppendLine("}");
if (LuaStruct.IsTableNameStart)
{
content.Append("return ").Append(tableInfo.TableName);
}
string exportString = content.ToString();
if (LuaStruct.ExportLuaIsFormat == false)
{
StringBuilder stringBuilder2 = new StringBuilder();
for (int i = 0; i < exportString.Length; ++i)
{
char c = exportString[i];
if (c == '\n' || c == '\r' || c.ToString() == " ")
{
}
else
{
stringBuilder2.Append(c);
}
}
exportString = stringBuilder2.ToString();
}
if (LuaStruct.IsNeedColumnInfo == true)
{
exportString = _GetColumnInfo(tableInfo) + exportString;
}
// 保存为lua文件
if (SaveLua.SaveLuaFile(tableInfo.ExcelName, ExcelMethods.GetSaveTableName(tableInfo.TableName), exportString) == true)
{
errorString = null;
return(true);
}
else
{
errorString = "保存为lua文件失败\n";
return(false);
}
}
public static bool ExportTableToJson(TableInfo tableInfo, out string errorString)
{
StringBuilder content = new StringBuilder();
// 若生成为各行数据对应的json object包含在一个json array的形式
if (JsonStruct.ExportJsonIsExportJsonArrayFormat == true)
{
// 生成json字符串开头，每行数据为一个json object，作为整张表json array的元素
content.Append("[");
// 逐行读取表格内容生成json
List<FieldInfo> allField = tableInfo.GetAllClientFieldInfo();
int dataCount = tableInfo.GetKeyColumnFieldInfo().Data.Count;
int fieldCount = allField.Count;
for (int row = 0; row < dataCount; ++row)
{
// 生成一行数据json object的开头
content.Append("{");
for (int column = 0; column < fieldCount; ++column)
{
string oneFieldString = _GetOneField(allField[column], row, out errorString);
if (errorString != null)
{
errorString = string.Format("导出表格{0}为json文件失败，", tableInfo.TableName) + errorString;
return false;
}
else
{
content.Append(oneFieldString);
}
}
// 去掉本行最后一个字段后多余的英文逗号，json语法不像lua那样最后一个字段后的逗号可有可无
content.Remove(content.Length - 1, 1);
// 生成一行数据json object的结尾
content.Append("}");
// 每行的json object后加英文逗号
content.Append(",");
}
// 去掉最后一行后多余的英文逗号，此处要特殊处理当表格中没有任何数据行时的情况
if (content.Length > 1)
content.Remove(content.Length - 1, 1);
// 生成json字符串结尾
content.Append("]");
}
else
{
// 生成json字符串开头，每行数据以表格主键列为key，各字段信息组成的json object为value，作为整张表json object的元素
content.Append("{");
// 逐行读取表格内容生成json
List<FieldInfo> allField = tableInfo.GetAllClientFieldInfo();
FieldInfo keyColumnInfo = tableInfo.GetKeyColumnFieldInfo();
int dataCount = keyColumnInfo.Data.Count;
int fieldCount = allField.Count;
for (int row = 0; row < dataCount; ++row)
{
// 将主键列的值作为key
string keyString = null;
StringBuilder contentkey = new StringBuilder();
if (keyColumnInfo.DataType == DataType.String)
{
keyString = _GetStringValue(keyColumnInfo, row);
contentkey.Append(keyString);
}
else if (keyColumnInfo.DataType == DataType.Int || keyColumnInfo.DataType == DataType.Long)
{
keyString = _GetNumberValue(keyColumnInfo, row);
contentkey.Append("\"").Append(keyString).Append("\"");
}
else
{
errorString = string.Format("ExportTableToJson函数中未定义{0}类型的主键数值导出至json文件的形式", keyColumnInfo.DataType);
AppLog.LogErrorAndExit(errorString);
return false;
}
StringBuilder contenvalue = new StringBuilder();
int startColumn = (JsonStruct.ExportJsonIsExportJsonMapIncludeKeyColumnValue == true ? 0 : 1);
for (int column = startColumn; column < fieldCount; ++column)
{
string oneFieldString = _GetOneField(allField[column], row, out errorString);
if (errorString != null)
{
errorString = string.Format("额外导出表格{0}为json文件失败，", tableInfo.TableName) + errorString;
return false;
}
else
{
contenvalue.Append(oneFieldString);
}
}
string str = contenvalue.ToString();
if (JsonStruct.ExportJsonIsExportJsonMapIncludeKeyColumnValue == true)
{
// 生成一行数据json object的开头
content.Append(contentkey);
content.Append(":{");
content.Append(contenvalue);
// 去掉本行最后一个字段后多余的英文逗号，json语法不像lua那样最后一个字段后的逗号可有可无
content.Remove(content.Length - 1, 1);
// 生成一行数据json object的结尾
content.Append("}");
// 每行的json object后加英文逗号
content.Append(",");
}
else if (str != "")
{
// 生成一行数据json object的开头
content.Append(contentkey);
content.Append(":{");
content.Append(contenvalue);
// 去掉本行最后一个字段后多余的英文逗号，json语法不像lua那样最后一个字段后的逗号可有可无
content.Remove(content.Length - 1, 1);
// 生成一行数据json object的结尾
content.Append("}");
// 每行的json object后加英文逗号
content.Append(",");
}
}
// 去掉最后一行后多余的英文逗号，此处要特殊处理当表格中没有任何数据行时的情况
if (content.Length > 1)
content.Remove(content.Length - 1, 1);
// 生成json字符串结尾
content.Append("}");
}
string exportString = content.ToString();
// 如果声明了要整理为带缩进格式的形式
if (JsonStruct.ExportJsonIsFormat == true)
exportString = _FormatJson(exportString);
// 保存为json文件
if (SaveJson.SaveJsonFile(tableInfo.ExcelName, ExcelMethods.GetSaveTableName(tableInfo.TableName), exportString) == true)
{
errorString = null;
//try
//{
// LitJson.JsonData jsonData = LitJson.JsonMapper.ToObject(exportString);
//}
//catch (LitJson.JsonException exception)
//{
// errorString = "错误：导出json出现异常，请检查导出的json及Excel\n";
//}
return true;
}
else
{
errorString = "保存为json文件失败\n";
return false;
}
}
public static bool ExportTableToErlang(TableInfo tableInfo, out string errorString)
{
StringBuilder content = new StringBuilder();
// 当前缩进量
int currentLevel = 1;
// 判断是否设置要将主键列的值作为导出的table中的元素
bool isAddKeyToLuaTable = tableInfo.TableConfigData2 != null && tableInfo.TableConfigData2.ContainsKey(ErlangStruct.Excel_Config_AddKeyToErlangTable) && tableInfo.TableConfigData2[ErlangStruct.Excel_Config_AddKeyToErlangTable].Count > 0 && "true".Equals(tableInfo.TableConfigData2[ErlangStruct.Excel_Config_AddKeyToErlangTable][0], StringComparison.CurrentCultureIgnoreCase);
//if(tableInfo.ExcelName== "ad_watch_videoType_info-视频类型信息")
//{
// errorString = "该表没有字段";
//}
// 逐行读取表格内容生成erlang table
List <FieldInfo> allField = tableInfo.GetAllFieldInfo();//获取所有字段，第2行没有定义也获取
int dataCount = tableInfo.GetKeyColumnFieldInfo().Data.Count;
for (int row = 0; row < dataCount; ++row)
{
// 将主键列作为key生成
FieldInfo keyColumnField = allField[0];
if (keyColumnField.DatabaseFieldName == null)
{
errorString = null;
return(true);
}
if (keyColumnField.DataType == DataType.Int || keyColumnField.DataType == DataType.Long)
{
content.Append("get(").Append(keyColumnField.Data[row]).Append(")->");
}
// 注意：像“1_2”这样的字符串作为table的key必须加[""]否则lua认为是语法错误
else if (keyColumnField.DataType == DataType.String)
{
string FieldString = keyColumnField.Data[row].ToString();// _GetOneField(keyColumnField, row, currentLevel, out errorString);
content.Append("get(").Append(FieldString.ToLower()).Append(")->");
}
else
{
errorString = "用ExportTableToErlang导出不支持的主键列数据类型";
AppLog.LogErrorAndExit(errorString);
return(false);
}
// content.Append(_GetErlangIndentation(currentLevel));
content.AppendLine(" #{");
// ++currentLevel;
// 如果设置了要将主键列的值作为导出的table中的元素
//if (isAddKeyToLuaTable == true)
//{
// content.Append(_GetErlangIndentation(currentLevel));
// content.Append(keyColumnField.FieldName);
// content.Append(" = ");
// if (keyColumnField.DataType == DataType.Int || keyColumnField.DataType == DataType.Long)
// content.Append(keyColumnField.Data[row]);
// else if (keyColumnField.DataType == DataType.String)
// content.AppendFormat("\"{0}\"", keyColumnField.Data[row]);
// content.AppendLine(",");
//}
// 将其他列依次作为value生成
int i = 0;
for (int column = 1; column < allField.Count; ++column)
{
string oneFieldString = _GetOneField(allField[column], row, currentLevel, out errorString);
if (oneFieldString == null)
{
continue;
}
else
{
i++;
}
// if (i > 1)
// {
if (ErlangStruct.ExportErlangIsFormat == true)
{
content.Append(_GetErlangIndentation(currentLevel));
}
// }
if (errorString != null)
{
errorString = string.Format("导出表格{0}失败，", tableInfo.TableName) + errorString;
return(false);
}
else
{
if (i > 1)
{
content.Append(",");
}
if (ErlangStruct.ExportErlangIsFormat == true)
{
content.Append("'").Append(allField[column].DatabaseFieldName.ToLower()).Append("' => ").AppendLine(oneFieldString);
}
else
{
content.Append("'").Append(allField[column].DatabaseFieldName.ToLower()).Append("' => ").Append(oneFieldString);
}
//content.AppendLine(",");
}
}
// 一行数据生成完毕后添加右括号结尾等
// --currentLevel;
// content.Append(_GetErlangIndentation(currentLevel));
//content.Remove(content.Length - 3, 1);
content.AppendLine("};");
}
string exportString2 = content.ToString();
//if (ErlangStruct.ExportErlangIsFormat == false)
//{
// StringBuilder stringBuilder2 = new StringBuilder();
// for (int i = 0; i < exportString2.Length; ++i)
// {
// char c = exportString2[i];
// if (c == '\n' || c == '\r')
// {
// }
// else
// stringBuilder2.Append(c);
// }
// exportString2 = stringBuilder2.ToString();
//}
StringBuilder stringBuilder = new StringBuilder();
// 生成数据内容开头
string erlangTableName = tableInfo.TableName;
TableAnalyzeHelper.GetOneConfigData(tableInfo, ErlangStruct.Excel_Config_ExportErlangOtherName, ref erlangTableName);
stringBuilder.AppendLine("%%--- coding:utf-8 ---");
stringBuilder.Append("-module(").Append(ErlangStruct.ExportNameBeforeAdd + erlangTableName).AppendLine(").");
stringBuilder.AppendLine(@"-export([get/1,get_list/0]).");
stringBuilder.Append(exportString2);
// 生成数据内容结尾
stringBuilder.AppendLine("get(_N) -> false.");
stringBuilder.AppendLine("get_list() ->");
stringBuilder.Append("\t[");
for (int i = 0; i < dataCount; i++)
{
string FieldString = allField[0].Data[i].ToString();// _GetOneField(allField[0], i, currentLevel, out errorString);
stringBuilder.Append(FieldString.ToLower()).Append(",");
}
stringBuilder.Remove(stringBuilder.Length - 1, 1);
stringBuilder.AppendLine("].");
string exportString = stringBuilder.ToString();
//if (ErlangStruct.IsNeedColumnInfo == true)
// exportString = _GetColumnInfo(tableInfo) + exportString;
// 保存为erlang文件
if (SaveErlang.SaveErlangFile(tableInfo.ExcelName, ExcelMethods.GetSaveTableName(erlangTableName), exportString) == true)
{
errorString = null;
return(true);
}
else
{
errorString = "保存为erlang文件失败\n";
return(false);
}
}
/// <summary>
/// 特殊导出erlang
/// </summary>
/// <param name="tableInfo"></param>
/// <param name="exportRule"></param>
/// <param name="errorString"></param>
/// <returns></returns>
public static bool SpecialExportTableToErlang(TableInfo tableInfo, string exportRule, out string errorString)
{
errorString = null;
exportRule = exportRule.Trim();
// 解析按这种方式导出后的erlang文件名
int colonIndex = exportRule.IndexOf(':');
if (colonIndex == -1)
{
errorString = string.Format("导出配置\"{0}\"定义错误，必须在开头声明导出lua文件名\n", exportRule);
return(false);
}
string fileName = exportRule.Substring(0, colonIndex).Trim();
// 判断是否在最后的花括号内声明table value中包含的字段
int leftBraceIndex = exportRule.LastIndexOf('{');
int rightBraceIndex = exportRule.LastIndexOf('}');
// 解析依次作为索引的字段名
string indexFieldNameString = null;
// 注意分析花括号时要考虑到未声明table value中的字段而在某索引字段完整性检查规则中用花括号声明了有效值的情况
if (exportRule.EndsWith("}") && leftBraceIndex != -1)
{
indexFieldNameString = exportRule.Substring(colonIndex + 1, leftBraceIndex - colonIndex - 1);
}
else
{
indexFieldNameString = exportRule.Substring(colonIndex + 1, exportRule.Length - colonIndex - 1);
}
string[] indexFieldDefine = indexFieldNameString.Split(new char[] { '-' }, System.StringSplitOptions.RemoveEmptyEntries);
// 用于索引的字段列表
List <FieldInfo> indexField = new List <FieldInfo>();
// 索引字段对应的完整性检查规则
List <string> integrityCheckRules = new List <string>();
if (indexFieldDefine.Length < 1)
{
errorString = string.Format("导出配置\"{0}\"定义错误，用于索引的字段不能为空，请按fileName:indexFieldName1-indexFieldName2{otherFieldName1,otherFieldName2}的格式配置\n", exportRule);
return(false);
}
// 检查字段是否存在且为int、float、string或lang型
foreach (string fieldDefine in indexFieldDefine)
{
string fieldName = null;
// 判断是否在字段名后用小括号声明了该字段的完整性检查规则
int leftBracketIndex = fieldDefine.IndexOf('(');
int rightBracketIndex = fieldDefine.IndexOf(')');
if (leftBracketIndex > 0 && rightBracketIndex > leftBracketIndex)
{
fieldName = fieldDefine.Substring(0, leftBracketIndex);
string integrityCheckRule = fieldDefine.Substring(leftBracketIndex + 1, rightBracketIndex - leftBracketIndex - 1).Trim();
if (string.IsNullOrEmpty(integrityCheckRule))
{
errorString = string.Format("导出配置\"{0}\"定义错误，用于索引的字段\"{1}\"若要声明完整性检查规则就必须在括号中填写否则不要加括号\n", exportRule, fieldName);
return(false);
}
integrityCheckRules.Add(integrityCheckRule);
}
else
{
fieldName = fieldDefine.Trim();
integrityCheckRules.Add(null);
}
FieldInfo fieldInfo = tableInfo.GetFieldInfoByFieldName(fieldName);
if (fieldInfo == null)
{
errorString = string.Format("导出配置\"{0}\"定义错误，声明的索引字段\"{1}\"不存在\n", exportRule, fieldName);
return(false);
}
if (fieldInfo.DataType != DataType.Int && fieldInfo.DataType != DataType.Long && fieldInfo.DataType != DataType.Float && fieldInfo.DataType != DataType.String && fieldInfo.DataType != DataType.Lang)
{
errorString = string.Format("导出配置\"{0}\"定义错误，声明的索引字段\"{1}\"为{2}型，但只允许为int、long、float、string或lang型\n", exportRule, fieldName, fieldInfo.DataType);
return(false);
}
// 对索引字段进行非空检查
if (fieldInfo.DataType == DataType.String)
{
FieldCheckRule stringNotEmptyCheckRule = new FieldCheckRule();
stringNotEmptyCheckRule.CheckType = TableCheckType.NotEmpty;
stringNotEmptyCheckRule.CheckRuleString = "notEmpty[trim]";
TableCheckHelper.CheckNotEmpty(fieldInfo, stringNotEmptyCheckRule, out errorString);
if (errorString != null)
{
errorString = string.Format("按配置\"{0}\"进行自定义导出错误，string型索引字段\"{1}\"中存在以下空值，而作为索引的key不允许为空\n{2}\n", exportRule, fieldName, errorString);
return(false);
}
}
else if (fieldInfo.DataType == DataType.Lang)
{
FieldCheckRule langNotEmptyCheckRule = new FieldCheckRule();
langNotEmptyCheckRule.CheckType = TableCheckType.NotEmpty;
langNotEmptyCheckRule.CheckRuleString = "notEmpty[key|value]";
TableCheckHelper.CheckNotEmpty(fieldInfo, langNotEmptyCheckRule, out errorString);
if (errorString != null)
{
errorString = string.Format("按配置\"{0}\"进行自定义导出错误，lang型索引字段\"{1}\"中存在以下空值，而作为索引的key不允许为空\n{2}\n", exportRule, fieldName, errorString);
return(false);
}
}
else if (CheckTableInfo.IsAllowedNullNumber == true)
{
FieldCheckRule numberNotEmptyCheckRule = new FieldCheckRule();
numberNotEmptyCheckRule.CheckType = TableCheckType.NotEmpty;
numberNotEmptyCheckRule.CheckRuleString = "notEmpty";
TableCheckHelper.CheckNotEmpty(fieldInfo, numberNotEmptyCheckRule, out errorString);
if (errorString != null)
{
errorString = string.Format("按配置\"{0}\"进行自定义导出错误，{1}型索引字段\"{2}\"中存在以下空值，而作为索引的key不允许为空\n{3}\n", exportRule, fieldInfo.DataType.ToString(), fieldName, errorString);
return(false);
}
}
indexField.Add(fieldInfo);
}
// 解析table value中要输出的字段名
List <FieldInfo> tableValueField = new List <FieldInfo>();
// 如果在花括号内配置了table value中要输出的字段名
if (exportRule.EndsWith("}") && leftBraceIndex != -1 && leftBraceIndex < rightBraceIndex)
{
string tableValueFieldName = exportRule.Substring(leftBraceIndex + 1, rightBraceIndex - leftBraceIndex - 1);
string[] fieldNames = tableValueFieldName.Split(new char[] { ',' }, System.StringSplitOptions.RemoveEmptyEntries);
if (fieldNames.Length < 1)
{
errorString = string.Format("导出配置\"{0}\"定义错误，花括号中声明的table value中的字段不能为空，请按fileName:indexFieldName1-indexFieldName2{otherFieldName1,otherFieldName2}的格式配置\n", exportRule);
return(false);
}
// 检查字段是否存在
foreach (string fieldName in fieldNames)
{
FieldInfo fieldInfo = tableInfo.GetFieldInfoByFieldName(fieldName);
if (fieldInfo == null)
{
errorString = string.Format("导出配置\"{0}\"定义错误，声明的table value中的字段\"{1}\"不存在\n", exportRule, fieldName);
return(false);
}
if (tableValueField.Contains(fieldInfo))
{
AppLog.LogWarning(string.Format("警告：导出配置\"{0}\"定义中，声明的table value中的字段存在重复，字段名为{1}（列号{2}），本工具只生成一次，请修正错误\n", exportRule, fieldName, ExcelMethods.GetExcelColumnName(fieldInfo.ColumnSeq + 1)));
}
else
{
tableValueField.Add(fieldInfo);
}
}
}
else if (exportRule.EndsWith("}") && leftBraceIndex == -1)
{
errorString = string.Format("导出配置\"{0}\"定义错误，声明的table value中花括号不匹配\n", exportRule);
return(false);
}
// 如果未在花括号内声明，则默认将索引字段之外的所有字段进行填充
else
{
List <string> indexFieldNameList = new List <string>(indexFieldDefine);
foreach (FieldInfo fieldInfo in tableInfo.GetAllClientFieldInfo())
{
if (!indexFieldNameList.Contains(fieldInfo.FieldName))
{
tableValueField.Add(fieldInfo);
}
}
}
// 解析完依次作为索引的字段以及table value中包含的字段后，按索引要求组成相应的嵌套数据结构
Dictionary <object, object> data = new Dictionary <object, object>();
int rowCount = tableInfo.GetKeyColumnFieldInfo().Data.Count;
for (int i = 0; i < rowCount; ++i)
{
Dictionary <object, object> temp = data;
// 生成除最内层的数据结构
for (int j = 0; j < indexField.Count - 1; ++j)
{
FieldInfo oneIndexField = indexField[j];
var tempData = oneIndexField.Data[i];
if (!temp.ContainsKey(tempData))
{
temp.Add(tempData, new Dictionary <object, object>());
}
temp = (Dictionary <object, object>)temp[tempData];
}
// 最内层的value存数据的int型行号（从0开始计）
FieldInfo lastIndexField = indexField[indexField.Count - 1];
var lastIndexFieldData = _GetOneField(lastIndexField, i, 1, out errorString);
if (!temp.ContainsKey(lastIndexFieldData))
{
temp.Add(lastIndexFieldData, i);
}
else
{
errorString = string.Format("错误：对表格{0}按\"{1}\"规则进行特殊索引导出时发现第{2}行与第{3}行在各个索引字段的值完全相同，导出被迫停止，请修正错误后重试\n", tableInfo.TableName, exportRule, i + ExcelTableSetting.DataFieldDataStartRowIndex + 1, temp[lastIndexFieldData]);
AppLog.LogErrorAndExit(errorString);
return(false);
}
}
// 进行数据完整性检查
if (CheckTableInfo.IsNeedCheck == true)
{
TableCheckHelper.CheckTableIntegrity(indexField, data, integrityCheckRules, out errorString);
if (errorString != null)
{
errorString = string.Format("错误：对表格{0}按\"{1}\"规则进行特殊索引导时未通过数据完整性检查，导出被迫停止，请修正错误后重试：\n{2}\n", tableInfo.TableName, exportRule, errorString);
return(false);
}
}
// 生成导出的文件内容
StringBuilder content = new StringBuilder();
// 生成数据内容开头
content.AppendLine("%%--- coding:utf-8 ---");
content.Append("-module(").Append(ErlangStruct.ExportNameBeforeAdd + tableInfo.TableName).AppendLine(").");
string oneFieldString = null;
// 当前缩进量
int currentLevel = 1;
foreach (var key in data.Keys)
{
// 生成key
if (key.GetType() == typeof(int) || key.GetType() == typeof(float))
{
content.Append("get(").Append(key).AppendLine(")->");
}
else if (key.GetType() == typeof(string))
{
content.Append("get(").Append(key).AppendLine(")->");
}
else
{
errorString = string.Format("SpecialExportTableToErlang中出现非法类型的索引列类型{0}", key.GetType());
AppLog.LogErrorAndExit(errorString);
return(false);
}
// content.Append(_GetErlangIndentation(currentLevel));
content.Append(" #{");
// 如果已是最内层，输出指定table value中的数据
if (data[key].GetType() == typeof(int))
{
int column = 0;
foreach (FieldInfo fieldInfo in tableValueField)
{
column++;
if (column > 1)
{
content.Append(_GetErlangIndentation(currentLevel));
}
int rowIndex = (int)data[key];
oneFieldString = _GetOneField(fieldInfo, rowIndex, currentLevel, out errorString);
if (errorString != null)
{
errorString = string.Format("导出表格{0}失败，", tableInfo.TableName) + errorString;
return(false);
}
else
{
if (column > 1)
{
content.Append(",");
}
content.Append("'").Append(fieldInfo.DatabaseFieldName).Append("' => ").AppendLine(oneFieldString);
}
}
}
content.AppendLine(" },");
}
// 生成数据内容结尾
content.AppendLine("get(_N) -> false.");
content.AppendLine("get_list() ->");
content.Append("\t[");
foreach (var key in data.Keys)
{
content.Append(key).Append(",");
}
content.Remove(content.Length - 1, 1);
content.Append("]");
string exportString = content.ToString();
//if (ErlangStruct.IsNeedColumnInfo == true)
// exportString = _GetColumnInfo(tableInfo) + exportString;
// 保存为erlang文件
if (SaveErlang.SaveErlangFile(tableInfo.ExcelName, ExcelMethods.GetSaveTableName(fileName), exportString) == true)
{
errorString = null;
return(true);
}
else
{
errorString = "保存为erlang文件失败\n";
return(false);
}
}
private static bool _InsertData(string tableName, TableInfo tableInfo, Export export, out string errorString)
{
List <FieldInfo> allDatabaseFieldInfo = GetAllDatabaseFieldInfo(tableInfo);
// 生成所有字段名对应的定义字符串
List <string> fileNames = new List <string>();
foreach (FieldInfo fieldInfo in allDatabaseFieldInfo)
{
fileNames.Add(string.Format("`{0}`", fieldInfo.DatabaseFieldName));
}
string fieldNameDefineString = Utils.CombineString(fileNames, ", ");
bool isWriteNullForEmptyString = export.IsExportNullString;
// 逐行生成插入数据的SQL语句中的value定义部分
StringBuilder valueDefineStringBuilder = new StringBuilder();
int count = tableInfo.GetKeyColumnFieldInfo().Data.Count;
if (count > 0)
{
for (int i = 0; i < count; ++i)
{
List <string> values = new List <string>();
foreach (FieldInfo fieldInfo in allDatabaseFieldInfo)
{
if (fieldInfo.Data[i] == null)
{
values.Add("NULL");
}
else if (fieldInfo.DataType == DataType.Date)
{
string toDatabaseFormatDefine = fieldInfo.ExtraParam[DateTimeTypeKey.toMySQL.ToString()].ToString();
//string toDatabaseFormatDefine = export.DateToExportFormat;
DateFormatType toDatabaseFormatType = DateTimeValue.GetDateFormatType(toDatabaseFormatDefine);
if (toDatabaseFormatType == DateFormatType.FormatString)
{
// 注意MySQL中的时间型，datetime和time型后面可用括号进行具体设置，date型没有
// MySQL中的date型插入数据时不允许含有时分秒，否则会报错，故这里强制采用MySQL默认的yyyy-MM-dd格式插入
if (fieldInfo.DatabaseFieldType.Equals("date", StringComparison.CurrentCultureIgnoreCase))
{
values.Add(string.Format("'{0}'", ((DateTime)(fieldInfo.Data[i])).ToString(defaultExportDateFormat)));
}
else if (fieldInfo.DatabaseFieldType.StartsWith("datetime", StringComparison.CurrentCultureIgnoreCase))
{
values.Add(string.Format("'{0}'", ((DateTime)(fieldInfo.Data[i])).ToString(DateTimeValue.APP_DEFAULT_DATE_FORMAT)));
}
// date型导出到MySQL中的其他数据类型字段如varchar，采用声明的指定格式
else
{
values.Add(string.Format("'{0}'", ((DateTime)(fieldInfo.Data[i])).ToString(toDatabaseFormatDefine)));
}
}
else if (toDatabaseFormatType == DateFormatType.ReferenceDateSec)
{
values.Add(string.Format("'{0}'", ((DateTime)fieldInfo.Data[i] - DateTimeValue.REFERENCE_DATE).TotalSeconds));
}
else if (toDatabaseFormatType == DateFormatType.ReferenceDateMsec)
{
values.Add(string.Format("'{0}'", ((DateTime)fieldInfo.Data[i] - DateTimeValue.REFERENCE_DATE).TotalMilliseconds));
}
else
{
errorString = "date型导出至MySQL的格式定义非法";
AppLog.LogErrorAndExit(errorString);
return(false);
}
}
else if (fieldInfo.DataType == DataType.Time)
{
string toDatabaseFormatDefine = fieldInfo.ExtraParam[DateTimeTypeKey.toMySQL.ToString()].ToString();
//string toDatabaseFormatDefine = export.TimeToExportFormat;
TimeFormatType toDatabaseFormatType = DateTimeValue.GetTimeFormatType(toDatabaseFormatDefine);
if (toDatabaseFormatType == TimeFormatType.FormatString)
{
if (fieldInfo.DatabaseFieldType.StartsWith("time", StringComparison.CurrentCultureIgnoreCase))
{
values.Add(string.Format("'{0}'", ((DateTime)(fieldInfo.Data[i])).ToString(DateTimeValue.APP_DEFAULT_TIME_FORMAT)));
}
else
{
values.Add(string.Format("'{0}'", ((DateTime)(fieldInfo.Data[i])).ToString(toDatabaseFormatDefine)));
}
}
else if (toDatabaseFormatType == TimeFormatType.ReferenceTimeSec)
{
values.Add(string.Format("'{0}'", ((DateTime)fieldInfo.Data[i] - DateTimeValue.REFERENCE_DATE).TotalSeconds));
}
else
{
errorString = "time型导出至MySQL的格式定义非法";
AppLog.LogErrorAndExit(errorString);
return(false);
}
}
else if (fieldInfo.DataType == DataType.Bool)
{
bool inputData = (bool)fieldInfo.Data[i];
// 如果数据库用bit数据类型表示bool型，比如要写入true，SQL语句中的1不能加单引号
if (fieldInfo.DatabaseFieldType.Equals("bit", StringComparison.CurrentCultureIgnoreCase) || fieldInfo.DatabaseFieldType.StartsWith("bit(", StringComparison.CurrentCultureIgnoreCase))
{
if (inputData == true)
{
values.Add("1");
}
else
{
values.Add("0");
}
}
else
{
// 如果数据库用tinyint(1)数据类型表示bool型，比如要写入true，SQL语句中可以写为'1'或者不带单引号的true
if (inputData == true)
{
values.Add("'1'");
}
else
{
values.Add("'0'");
}
}
}
else if (fieldInfo.DataType == DataType.Json)
{
// json型直接向数据库写入原始json字符串，但需要对\进行转义
values.Add(string.Format("'{0}'", fieldInfo.JsonString[i]).Replace("\\", "\\\\"));
}
else if (fieldInfo.DataType == DataType.MapString)
{
// mapString型也直接写入原始mapString数据字符串，并对\进行转义
values.Add(string.Format("'{0}'", fieldInfo.JsonString[i]).Replace("\\", "\\\\"));
}
// 这里需要自行处理数据库中某些数据类型（如datetime）中不允许插入空字符串的情况，以及用户设置的string型中空单元格导出至数据库的形式
else if (string.IsNullOrEmpty(fieldInfo.Data[i].ToString()))
{
if (fieldInfo.DatabaseFieldType.StartsWith("datetime", StringComparison.CurrentCultureIgnoreCase))
{
values.Add("NULL");
}
else if (fieldInfo.DataType == DataType.String && isWriteNullForEmptyString == true)
{
values.Add("NULL");
}
else
{
values.Add(string.Format("'{0}'", fieldInfo.Data[i].ToString()));
}
}
else
{
// 注意对\进行转义
values.Add(string.Format("'{0}'", fieldInfo.Data[i].ToString()).Replace("\\", "\\\\"));
}
}
valueDefineStringBuilder.AppendFormat("({0}),", Utils.CombineString(values, ","));
}
// 去掉末尾多余的逗号
string valueDefineString = valueDefineStringBuilder.ToString();
valueDefineString = valueDefineString.Substring(0, valueDefineString.Length - 1);
string insertSqlString = string.Format(insertDataSQL, _CombineDatabaseTableFullName(tableName), fieldNameDefineString, valueDefineString);
// 执行插入操作
try
{
MySqlCommand cmd = new MySqlCommand(insertSqlString, conn);
int insertCount = cmd.ExecuteNonQuery();
if (insertCount < count)
{
errorString = string.Format("需要插入{0}条数据但仅插入了{1}条", count, insertCount);
return(false);
}
else
{
errorString = null;
return(true);
}
}
catch (MySqlException exception)
{
errorString = exception.Message;
return(false);
}
}
else
{
errorString = null;
return(true);
}
}
/// <summary>
/// 将tableString类型数据字符串中的某个所填数据转为需要输出的字符串
/// </summary>
private static string _GetDataStringInTableString(string inputData, DataType dataType, out string errorString)
{
string result = null;
errorString = null;
switch (dataType)
{
case DataType.Bool:
{
if ("1".Equals(inputData) || "true".Equals(inputData, StringComparison.CurrentCultureIgnoreCase))
{
result = "true";
}
else if ("0".Equals(inputData) || "false".Equals(inputData, StringComparison.CurrentCultureIgnoreCase))
{
result = "false";
}
else
{
errorString = string.Format("输入的\"{0}\"不是合法的bool值，正确填写bool值方式为填1或true代表真，0或false代表假", inputData);
}
break;
}
case DataType.Int:
case DataType.Long:
{
long longValue;
bool isValid = long.TryParse(inputData, out longValue);
if (isValid)
{
result = longValue.ToString();
}
else
{
errorString = string.Format("输入的\"{0}\"不是合法的{1}类型的值", inputData, dataType);
}
break;
}
case DataType.Float:
{
float floatValue;
bool isValid = float.TryParse(inputData, out floatValue);
if (isValid)
{
result = floatValue.ToString();
}
else
{
errorString = string.Format("输入的\"{0}\"不是合法的float类型的值", inputData);
}
break;
}
case DataType.String:
{
result = inputData;
break;
}
case DataType.Lang:
{
if (AppLang.LangData.ContainsKey(inputData))
{
string langValue = AppLang.LangData[inputData];
if (langValue.Contains("\"") || langValue.Contains("\\") || langValue.Contains("/") || langValue.Contains(",") || langValue.Contains(";"))
{
errorString = string.Format("tableString中的lang型数据中不允许出现英文引号、斜杠、逗号、分号，你输入的key（{0}）对应在lang文件中的值为\"{1}\"", inputData, langValue);
}
else
{
result = langValue;
}
}
else
{
errorString = string.Format("输入的lang型数据的key（{0}）在lang文件中找不到对应的value", inputData);
}
break;
}
default:
{
AppLog.LogErrorAndExit(string.Format("错误：用_GetDataInTableString函数解析了tableString中不支持的数据类型{0}", dataType));
break;
}
}
return(result);
}
private static string _GetTableStringValue(FieldInfo fieldInfo, int row, int level, out string errorString)
{
errorString = null;
if (fieldInfo.Data[row] == null)
{
return("nil");
}
StringBuilder content = new StringBuilder();
string inputData = fieldInfo.Data[row].ToString();
// tableString字符串中不允许出现英文引号、斜杠
if (inputData.Contains("\"") || inputData.Contains("\\") || inputData.Contains("/"))
{
errorString = "tableString字符串中不允许出现英文引号、斜杠";
return(null);
}
// 包裹tableString所生成table的左括号
content.AppendLine("{");
++level;
// 每组数据间用英文分号分隔，最终每组数据会生成一个lua table
string[] allDataString = inputData.Split(new char[] { ';' }, System.StringSplitOptions.RemoveEmptyEntries);
// 记录每组数据中的key值（转为字符串后的），不允许出现相同的key（key：每组数据中的key值， value：第几组数据，从0开始记）
Dictionary <string, int> stringKeys = new Dictionary <string, int>();
for (int i = 0; i < allDataString.Length; ++i)
{
content.Append(_GetLuaIndentation(level));
// 根据key的格式定义生成key
switch (fieldInfo.TableStringFormatDefine.KeyDefine.KeyType)
{
case TableStringKeyType.Seq:
{
content.AppendFormat("[{0}]", i + 1);
break;
}
case TableStringKeyType.DataInIndex:
{
string value = _GetDataInIndexType(fieldInfo.TableStringFormatDefine.KeyDefine.DataInIndexDefine, allDataString[i], out errorString);
if (errorString == null)
{
if (fieldInfo.TableStringFormatDefine.KeyDefine.DataInIndexDefine.DataType == DataType.Int || fieldInfo.TableStringFormatDefine.KeyDefine.DataInIndexDefine.DataType == DataType.Long)
{
// 检查key是否在该组数据中重复
if (stringKeys.ContainsKey(value))
{
errorString = string.Format("第{0}组数据与第{1}组数据均为相同的key（{2}）", stringKeys[value] + 1, i + 1, value);
}
else
{
stringKeys.Add(value, i);
content.AppendFormat("[{0}]", value);
}
}
else if (fieldInfo.TableStringFormatDefine.KeyDefine.DataInIndexDefine.DataType == DataType.String)
{
// string型的key不允许为空或纯空格且必须符合变量名的规范
value = value.Trim();
if (TableCheckHelper.CheckFieldName(value, out errorString))
{
// 检查key是否在该组数据中重复
if (stringKeys.ContainsKey(value))
{
errorString = string.Format("第{0}组数据与第{1}组数据均为相同的key（{2}）", stringKeys[value] + 1, i + 1, value);
}
else
{
stringKeys.Add(value, i);
content.Append(value);
}
}
else
{
errorString = "string型的key不符合变量名定义规范，" + errorString;
}
}
else
{
AppLog.LogErrorAndExit("错误：用_GetTableStringValue函数导出非int、long或string型的key值");
return(null);
}
}
break;
}
default:
{
AppLog.LogErrorAndExit("错误：用_GetTableStringValue函数导出未知类型的key");
return(null);
}
}
if (errorString != null)
{
errorString = string.Format("tableString中第{0}组数据（{1}）的key数据存在错误，", i + 1, allDataString[i]) + errorString;
return(null);
}
content.Append(" = ");
// 根据value的格式定义生成value
switch (fieldInfo.TableStringFormatDefine.ValueDefine.ValueType)
{
case TableStringValueType.True:
{
content.Append("true");
break;
}
case TableStringValueType.DataInIndex:
{
string value = _GetDataInIndexType(fieldInfo.TableStringFormatDefine.ValueDefine.DataInIndexDefine, allDataString[i], out errorString);
if (errorString == null)
{
DataType dataType = fieldInfo.TableStringFormatDefine.ValueDefine.DataInIndexDefine.DataType;
if (dataType == DataType.String || dataType == DataType.Lang)
{
content.AppendFormat("\"{0}\"", value);
}
else
{
content.Append(value);
}
}
break;
}
case TableStringValueType.Table:
{
content.AppendLine("{");
++level;
// 依次输出table中定义的子元素
foreach (TableElementDefine elementDefine in fieldInfo.TableStringFormatDefine.ValueDefine.TableValueDefineList)
{
content.Append(_GetLuaIndentation(level));
content.Append(elementDefine.KeyName);
content.Append(" = ");
string value = _GetDataInIndexType(elementDefine.DataInIndexDefine, allDataString[i], out errorString);
if (errorString == null)
{
if (elementDefine.DataInIndexDefine.DataType == DataType.String || elementDefine.DataInIndexDefine.DataType == DataType.Lang)
{
content.AppendFormat("\"{0}\"", value);
}
else
{
content.Append(value);
}
}
content.AppendLine(",");
}
--level;
content.Append(_GetLuaIndentation(level));
content.Append("}");
break;
}
default:
{
AppLog.LogErrorAndExit("错误：用_GetTableStringValue函数导出未知类型的value");
return(null);
}
}
if (errorString != null)
{
errorString = string.Format("tableString中第{0}组数据（{1}）的value数据存在错误，", i + 1, allDataString[i]) + errorString;
return(null);
}
// 每组数据生成完毕后加逗号并换行
content.AppendLine(",");
}
// 包裹tableString所生成table的右括号
--level;
content.Append(_GetLuaIndentation(level));
content.Append("}");
return(content.ToString());
}
private static void _AnalyzeJsonData(StringBuilder content, JsonData jsonData, int level)
{
if (jsonData == null)
{
// 处理键值对中的值为null的情况
content.Append("nil");
}
else if (jsonData.IsObject == true)
{
content.AppendLine("{");
++level;
List <string> childKeyNames = new List <string>(jsonData.Keys);
int childCount = jsonData.Count;
for (int i = 0; i < childCount; ++i)
{
content.Append(_GetLuaIndentation(level));
// 如果键名为数字，需要加方括号和引号
string keyName = childKeyNames[i];
double temp;
if (double.TryParse(keyName, out temp) == true)
{
content.AppendFormat("[\"{0}\"]", keyName);
}
else
{
content.Append(childKeyNames[i]);
}
content.Append(" = ");
_AnalyzeJsonData(content, jsonData[i], level);
content.AppendLine(",");
}
--level;
content.Append(_GetLuaIndentation(level));
content.Append("}");
}
else if (jsonData.IsArray == true)
{
content.AppendLine("{");
++level;
int childCount = jsonData.Count;
for (int i = 0; i < childCount; ++i)
{
content.Append(_GetLuaIndentation(level));
if (LuaStruct.IsArrayFieldName)
{
content.AppendFormat("[{0}] = ", i + 1);
}
_AnalyzeJsonData(content, jsonData[i], level);
content.AppendLine(",");
}
--level;
content.Append(_GetLuaIndentation(level));
content.Append("}");
}
else if (jsonData.IsString == true)
{
// 将单元格中填写的英文引号进行转义，使得单元格中填写123"456时，最终生成的lua文件中为xx = "123\"456"
// 将单元格中手工按下的回车变成"\n"输出到lua文件中，单元格中输入的"\n"等原样导出到lua文件中使其能被lua转义处理
content.AppendFormat("\"{0}\"", jsonData.ToString().Replace("\n", "\\n").Replace("\"", "\\\""));
}
else if (jsonData.IsBoolean == true)
{
content.AppendFormat(jsonData.ToString().ToLower());
}
else if (jsonData.IsInt == true || jsonData.IsLong == true || jsonData.IsDouble == true)
{
content.AppendFormat(jsonData.ToString());
}
else
{
AppLog.LogErrorAndExit("用_AnalyzeJsonData解析了未知的JsonData类型");
}
}
public static void ExportToTxt()
{
string ExportType = "Txt";
if (AppValues.ConfigData.ContainsKey("AllExport" + ExportType))
{
if (string.Equals("false", AppValues.ConfigData["AllExport" + ExportType].Trim().ToLower()))
{
return;
}
}
else
{
return;
}
string errorString = null;
BatExportPublicSetting batExportPublicSetting = new BatExportPublicSetting();
batExportPublicSetting.IsExport = true;
batExportPublicSetting.ExcelNameSplitString = "-";
batExportPublicSetting.ExportNameAfterLanguageMark = "";
BatExportSetting batExportSetting = new BatExportSetting();
batExportSetting.ExportTypeParam = "ExportTxt";
batExportSetting.ExportPath = ExcelFolder.ExcelPath;// FileModule.CombinePath(AppDomain.CurrentDomain.SetupInformation.ApplicationBase, "ExportTxt");
batExportSetting.IsExport = true;
batExportSetting.IsExportKeepDirectoryStructure = true;
batExportSetting.ExportExtension = "txt";
batExportSetting.ExportNameBeforeAdd = "";
batExportPublicSetting.ExportNameAfterLanguageMark = "-data";
batExportSetting.IsExportNullNumber = true;
batExportSetting.IsExportNullString = true;
batExportSetting.IsExportNullJson = false;
batExportSetting.IsExportNullArray = true;
batExportSetting.IsExportNullDict = true;
batExportSetting.IsExportNullBool = false;
batExportSetting.IsExportNullDate = false;
batExportSetting.IsExportNullTime = false;
batExportSetting.IsExportNullLang = false;
batExportSetting.IsExportFormat = true;
batExportSetting.IsExportFieldComment = false;
batExportSetting.ExportTopWords = "";
batExportSetting.ExportIndentationString = ""; //缩进符
batExportSetting.ExportSpaceString = "\t"; //间隔符
batExportSetting.ExportLineString = "\n"; //换行符
batExportSetting.IsExportJsonArrayFormat = false;
batExportSetting.IsExportJsonMapIncludeKeyColumnValue = false;
batExportSetting.IsArrayFieldName = false;
batExportSetting.IsTableNameStart = false;
batExportSetting.IsAddKeyToLuaTable = false;
batExportSetting.GetParamValue();
foreach (KeyValuePair <string, TableInfo> kvp in AppValues.TableInfo)
{
TableInfo tableInfo = kvp.Value;
errorString = null;
ExcelConfigSetting excelConfigSetting = new ExcelConfigSetting();
excelConfigSetting.IsExportParam = "Export" + ExportType;// ExportType + "IsExport";
excelConfigSetting.ExportPathParam = ExportType + "ExportPath";
excelConfigSetting.IsExportKeepDirectoryStructureParam = ExportType + "ExportPath";
excelConfigSetting.ExportNameParam = ExportType + "ExportName";
excelConfigSetting.ExcelNameSplitStringParam = ExportType + "ExcelNameSplitString";
excelConfigSetting.ExportExtensionParam = ExportType + "ExportExtension";
excelConfigSetting.ExportNameBeforeAddParam = ExportType + "ExportNameBeforeAdd";
excelConfigSetting.ExportNameAfterLanguageMarkParam = ExportType + "ExportNameAfterLanguageMark";
excelConfigSetting.IsExportNullNumberParam = ExportType + "IsExportNullNumber";
excelConfigSetting.IsExportNullStringParam = ExportType + "IsExportNullString";
excelConfigSetting.IsExportNullJsonParam = ExportType + "IsExportNullJson";
excelConfigSetting.IsExportNullArrayParam = ExportType + "IsExportNullArray";
excelConfigSetting.IsExportNullDictParam = ExportType + "IsExportNullDict";
excelConfigSetting.IsExportNullBoolParam = ExportType + "IsExportNullBool";
excelConfigSetting.IsExportNullDateParam = ExportType + "IsExportNullDate";
excelConfigSetting.IsExportNullTimeParam = ExportType + "IsExportNullTime";
excelConfigSetting.IsExportNullLangParam = ExportType + "IsExportNullLang";
excelConfigSetting.IsExportFormatParam = ExportType + "IsExportFormat";
excelConfigSetting.IsExportFieldCommentParam = ExportType + "ExportFieldComment";
excelConfigSetting.ExportTopWordsParam = ExportType + "ExportTopWords";
excelConfigSetting.ExportIndentationStringParam = ExportType + "ExportIndentationString";
excelConfigSetting.ExportSpaceStringParam = ExportType + "ExportSpaceString";
excelConfigSetting.IsExportJsonArrayFormatParam = ExportType + "IsExportJsonArrayFormat";
excelConfigSetting.IsExportJsonMapIncludeKeyColumnValueParam = ExportType + "IsExportJsonMapIncludeKeyColumnValue";
excelConfigSetting.IsArrayFieldNameParam = ExportType + "IsArrayFieldName";
excelConfigSetting.IsTableNameStartParam = ExportType + "IsTableNameStart";
excelConfigSetting.IsAddKeyToLuaTableParam = ExportType + "IsAddKeyToLuaTable";
excelConfigSetting.DateToExportFormatParam = ExportType + "DateToExportFormat";
excelConfigSetting.TimeToExportFormatParam = ExportType + "TimeToExportFormat";
if (AppValues.ConfigData.ContainsKey("Export" + ExportType))
{
excelConfigSetting.IsExportParam = AppValues.ConfigData["Export" + ExportType].Trim();
}
if (AppValues.ConfigData.ContainsKey(ExportType + "ExportPath"))
{
excelConfigSetting.ExportPathParam = AppValues.ConfigData[ExportType + "ExportPath"].Trim();
}
if (AppValues.ConfigData.ContainsKey(ExportType + "IsExportKeepDirectoryStructure"))
{
excelConfigSetting.IsExportKeepDirectoryStructureParam = AppValues.ConfigData[ExportType + "IsExportKeepDirectoryStructure"].Trim();
}
if (AppValues.ConfigData.ContainsKey(ExportType + "ExportName"))
{
excelConfigSetting.ExportNameParam = AppValues.ConfigData[ExportType + "ExportName"].Trim();
}
if (AppValues.ConfigData.ContainsKey(ExportType + "ExcelNameSplitString"))
{
excelConfigSetting.ExcelNameSplitStringParam = AppValues.ConfigData[ExportType + "ExcelNameSplitString"].Trim();
}
if (AppValues.ConfigData.ContainsKey(ExportType + "ExportExtension"))
{
excelConfigSetting.ExportExtensionParam = AppValues.ConfigData[ExportType + "ExportExtension"].Trim();
}
if (AppValues.ConfigData.ContainsKey(ExportType + "ExportNameBeforeAdd"))
{
excelConfigSetting.ExportNameBeforeAddParam = AppValues.ConfigData[ExportType + "ExportNameBeforeAdd"].Trim();
}
if (AppValues.ConfigData.ContainsKey(ExportType + "ExportNameAfterLanguageMark"))
{
excelConfigSetting.ExportNameAfterLanguageMarkParam = AppValues.ConfigData[ExportType + "ExportNameAfterLanguageMark"].Trim();
}
if (AppValues.ConfigData.ContainsKey(ExportType + "IsExportNullNumber"))
{
excelConfigSetting.IsExportNullNumberParam = AppValues.ConfigData[ExportType + "IsExportNullNumber"].Trim();
}
if (AppValues.ConfigData.ContainsKey(ExportType + "IsExportNullString"))
{
excelConfigSetting.IsExportNullStringParam = AppValues.ConfigData[ExportType + "IsExportNullString"].Trim();
}
if (AppValues.ConfigData.ContainsKey(ExportType + "IsExportNullJson"))
{
excelConfigSetting.IsExportNullJsonParam = AppValues.ConfigData[ExportType + "IsExportNullJson"].Trim();
}
if (AppValues.ConfigData.ContainsKey(ExportType + "IsExportNullArray"))
{
excelConfigSetting.IsExportNullArrayParam = AppValues.ConfigData[ExportType + "IsExportNullArray"].Trim();
}
if (AppValues.ConfigData.ContainsKey(ExportType + "IsExportNullDict"))
{
excelConfigSetting.IsExportNullDictParam = AppValues.ConfigData[ExportType + "IsExportNullDict"].Trim();
}
if (AppValues.ConfigData.ContainsKey(ExportType + "IsExportNullBool"))
{
excelConfigSetting.IsExportNullBoolParam = AppValues.ConfigData[ExportType + "IsExportNullBool"].Trim();
}
if (AppValues.ConfigData.ContainsKey(ExportType + "IsExportNullDate"))
{
excelConfigSetting.IsExportNullDateParam = AppValues.ConfigData[ExportType + "IsExportNullDate"].Trim();
}
if (AppValues.ConfigData.ContainsKey(ExportType + "IsExportNullTime"))
{
excelConfigSetting.IsExportNullTimeParam = AppValues.ConfigData[ExportType + "IsExportNullTime"].Trim();
}
if (AppValues.ConfigData.ContainsKey(ExportType + "IsExportNullLang"))
{
excelConfigSetting.IsExportNullLangParam = AppValues.ConfigData[ExportType + "IsExportNullLang"].Trim();
}
if (AppValues.ConfigData.ContainsKey(ExportType + "IsExportFormat"))
{
excelConfigSetting.IsExportFormatParam = AppValues.ConfigData[ExportType + "IsExportFormat"].Trim();
}
if (AppValues.ConfigData.ContainsKey(ExportType + "ExportFieldComment"))
{
excelConfigSetting.IsExportFieldCommentParam = AppValues.ConfigData[ExportType + "ExportFieldComment"].Trim();
}
if (AppValues.ConfigData.ContainsKey(ExportType + "ExportTopWords"))
{
excelConfigSetting.ExportTopWordsParam = AppValues.ConfigData[ExportType + "ExportTopWords"].Trim();
}
if (AppValues.ConfigData.ContainsKey(ExportType + "ExportIndentationString"))
{
excelConfigSetting.ExportIndentationStringParam = AppValues.ConfigData[ExportType + "ExportIndentationString"].Trim();
}
if (AppValues.ConfigData.ContainsKey(ExportType + "ExportSpaceString"))
{
excelConfigSetting.ExportSpaceStringParam = AppValues.ConfigData[ExportType + "ExportSpaceString"].Trim();
}
if (AppValues.ConfigData.ContainsKey(ExportType + "ExportLineString"))
{
excelConfigSetting.ExportLineStringParam = AppValues.ConfigData[ExportType + "ExportLineString"].Trim();
}
if (AppValues.ConfigData.ContainsKey(ExportType + "IsExportJsonArrayFormat"))
{
excelConfigSetting.IsExportJsonArrayFormatParam = AppValues.ConfigData[ExportType + "IsExportJsonArrayFormat"].Trim();
}
if (AppValues.ConfigData.ContainsKey(ExportType + "IsExportJsonMapIncludeKeyColumnValue"))
{
excelConfigSetting.IsExportJsonMapIncludeKeyColumnValueParam = AppValues.ConfigData[ExportType + "IsExportJsonMapIncludeKeyColumnValue"].Trim();
}
if (AppValues.ConfigData.ContainsKey(ExportType + "IsArrayFieldName"))
{
excelConfigSetting.IsArrayFieldNameParam = AppValues.ConfigData[ExportType + "IsArrayFieldName"].Trim();
}
if (AppValues.ConfigData.ContainsKey(ExportType + "IsTableNameStart"))
{
excelConfigSetting.IsTableNameStartParam = AppValues.ConfigData[ExportType + "IsTableNameStart"].Trim();
}
if (AppValues.ConfigData.ContainsKey(ExportType + "IsAddKeyToLuaTable"))
{
excelConfigSetting.IsAddKeyToLuaTableParam = AppValues.ConfigData[ExportType + "IsAddKeyToLuaTable"].Trim();
}
if (AppValues.ConfigData.ContainsKey(ExportType + "DateToExportFormat"))
{
excelConfigSetting.DateToExportFormatParam = AppValues.ConfigData[ExportType + "DateToExportFormat"].Trim();
}
if (AppValues.ConfigData.ContainsKey(ExportType + "TimeToExportFormat"))
{
excelConfigSetting.TimeToExportFormatParam = AppValues.ConfigData[ExportType + "TimeToExportFormat"].Trim();
}
if (AppValues.ConfigData.ContainsKey("SpecialExport" + ExportType))
{
excelConfigSetting.TimeToExportFormatParam = AppValues.ConfigData["SpecialExport" + ExportType].Trim();
}
excelConfigSetting.GetParamValue(tableInfo);
Export export = new Export();
export.GetValue(tableInfo, excelConfigSetting, batExportSetting, batExportPublicSetting);
if (export.IsExport == false)
{
continue;
}
if (AppValues.MergeTableList != null && AppValues.MergeTableList.ContainsKey(tableInfo.TableName))
{
AppLog.Log(string.Format("\n开始导出{0}：", ExportType), ConsoleColor.Green, false);
AppLog.Log(string.Format("{0}", tableInfo.TableName), ConsoleColor.Green);
ExportOneMergeTable(tableInfo, export, out errorString);
if (errorString != null)
{
AppLog.LogErrorAndExit(errorString);
}
}
else
{
AppLog.Log(string.Format("\n开始导出{0}：", ExportType), ConsoleColor.Green, false);
AppLog.Log(string.Format("{0}", tableInfo.ExcelNameTips), ConsoleColor.Green);
ExportOneTable(tableInfo, export, out errorString);
if (errorString != null)
{
AppLog.LogErrorAndExit(errorString);
}
}
}
}
private static string _GetOneField(FieldInfo fieldInfo, int row, int level, out string errorString, bool isExportLuaNilConfig = true)
{
errorString = null;
// 对应数据值
string value = null;
switch (fieldInfo.DataType)
{
case DataType.Int:
case DataType.Long:
case DataType.Float:
{
value = _GetNumberValue(fieldInfo, row, level);
break;
}
case DataType.String:
{
value = _GetStringValue(fieldInfo, row, level);
break;
}
case DataType.Bool:
{
value = _GetBoolValue(fieldInfo, row, level);
break;
}
case DataType.Lang:
{
value = _GetLangValue(fieldInfo, row, level);
break;
}
case DataType.Date:
{
value = _GetDateValue(fieldInfo, row, level);
break;
}
case DataType.Time:
{
value = _GetTimeValue(fieldInfo, row, level);
break;
}
case DataType.Json:
{
value = _GetJsonValue(fieldInfo, row, level);
break;
}
case DataType.TableString:
{
value = _GetTableStringValue(fieldInfo, row, level, out errorString);
break;
}
case DataType.MapString:
{
value = _GetMapStringValue(fieldInfo, row, level);
break;
}
case DataType.Dict:
case DataType.Array:
{
value = _GetSetValue(fieldInfo, row, level, out errorString);
break;
}
default:
{
errorString = string.Format("_GetOneField函数中未定义{0}类型数据导出至lua文件的形式", fieldInfo.DataType);
AppLog.LogErrorAndExit(errorString);
return(null);
}
}
if (errorString != null)
{
errorString = string.Format("第{0}行第{1}列的数据存在错误无法导出，", row + ExcelTableSetting.DataFieldDataStartRowIndex + 1, ExcelMethods.GetExcelColumnName(fieldInfo.ColumnSeq + 1)) + errorString;
return(null);
}
StringBuilder content = new StringBuilder();
if (LuaStruct.IsExportLuaNilConfig)
{
// 变量名前的缩进
content.Append(_GetLuaIndentation(level));
if (LuaStruct.IsArrayFieldName == true)
{
// 变量名，注意array下属的子元素在json中不含key的声明
if (fieldInfo.ParentField != null && fieldInfo.ParentField.DataType == DataType.Array)
{
content.Append(fieldInfo.FieldName);
content.Append(" = ");
}
}
// 变量名，注意array下属的子元素在json中不含key的声明
if (!(fieldInfo.ParentField != null && fieldInfo.ParentField.DataType == DataType.Array))
{
content.Append(fieldInfo.FieldName);
content.Append(" = ");
}
content.Append(value);
// 一个字段结尾加逗号
content.AppendLine(",");
return(content.ToString());
}
else
{
if (value != "nil")
{
// 变量名前的缩进
content.Append(_GetLuaIndentation(level));
if (LuaStruct.IsArrayFieldName == true)
{
// 变量名，注意array下属的子元素在json中不含key的声明
if (fieldInfo.ParentField != null && fieldInfo.ParentField.DataType == DataType.Array)
{
content.Append(fieldInfo.FieldName);
content.Append(" = ");
}
}
// 变量名，注意array下属的子元素在json中不含key的声明
if (!(fieldInfo.ParentField != null && fieldInfo.ParentField.DataType == DataType.Array))
{
content.Append(fieldInfo.FieldName);
content.Append(" = ");
}
content.Append(value);
// 一个字段结尾加逗号
content.AppendLine(",");
return(content.ToString());
}
else
{
return(null);
}
}
}
private void SetChildParam(int i)
{
if (Arg == null)
{
return;
}
AppLog.Log(string.Format("检查参数：{0}", Arg), ConsoleColor.Green);
if (Arg.Length >= 2)//形式如：a(b) 最少是4个字符
{
if (Arg.StartsWith("“") || Arg.StartsWith("”"))
{
Arg = Arg.Substring(1);
}
if (Arg.EndsWith("“") || Arg.EndsWith("”"))
{
Arg = Arg.Substring(0, Arg.Length - 1);
}
int leftBracketIndex = Arg.IndexOf(ParamNameLeft);
// int rightBracketIndex = paramString.LastIndexOf(')');
ParamName = Arg.Substring(0, leftBracketIndex);
}
else
{
ParamName = null;
AppLog.LogErrorAndExit(string.Format("第{0}个参数错误，{1}", i, Arg));
}
if (Arg.Length >= 4)//形式如：a(b) 最少是4个字符
{
int leftBracketIndex = Arg.IndexOf(ParamNameLeft);
int rightBracketIndex = Arg.LastIndexOf(ParamNameRight);
if (rightBracketIndex == -1)
{
AppLog.LogErrorAndExit(string.Format("参数{0}错误，应形如：类型(参数1=值1)", Arg));
}
string paramStringAll = Arg.Substring(leftBracketIndex + 1, rightBracketIndex - leftBracketIndex - 1);
// 通过|分隔各个参数，但因为用户设置的TXT文件中的字段分隔符本身可能为|，本工具采用\|配置进行转义，故需要自行从头遍历查找真正的参数分隔符
// 记录参数分隔符的下标位置
List <int> splitParamCharIndex = new List <int>();
for (int index = 0; index < paramStringAll.Length; ++index)
{
char c = paramStringAll[index];
if (c == ChildParamSplit && (index < 1 || (index > 1 && paramStringAll[index - 1] != '\\')))
{
splitParamCharIndex.Add(index);
}
}
// 通过识别的参数分隔符，分隔各个参数
List <string> paramStringList = new List <string>();
int lastSplitParamChatIndex = -1;
foreach (int index in splitParamCharIndex)
{
paramStringList.Add(paramStringAll.Substring(lastSplitParamChatIndex + 1, index - lastSplitParamChatIndex - 1));
lastSplitParamChatIndex = index;
}
// 还要加上最后一个|后面的参数
if (lastSplitParamChatIndex == -1)
{
paramStringList.Add(paramStringAll);
}
else if (lastSplitParamChatIndex + 1 < paramStringAll.Length - 1)
{
paramStringList.Add(paramStringAll.Substring(lastSplitParamChatIndex + 1));
}
string[] param = null;
foreach (string s in paramStringList)
{
if (!s.Contains(ChildParamValueSplit.ToString()))
{
AppLog.LogErrorAndExit(string.Format("错误：BAT参数{0}\n中的{1}设置有错误，应该是形如：参数1=值1", Arg, s));
}
param = s.Split(new char[] { ChildParamValueSplit }, StringSplitOptions.RemoveEmptyEntries);
//是否需要判断param[0], param[1]不为空？？？
if (param.Length < 2)
{
AppLog.LogErrorAndExit(string.Format("错误：BAT参数{0}\n中的{1}设置有错误，应该是形如：参数1=值1", Arg, s));
}
BatChildParam batChildParam = new BatChildParam(param[1].Trim(), ChildParamListSplit);
if (!ChildParam.ContainsKey(param[0].Trim()))
{
ChildParam.Add(param[0].Trim(), batChildParam);
}
else
{
AppLog.LogErrorAndExit(string.Format("bat参数错误,存在2个以上同名子参数，{0}", Arg));
}
}
}
else
{
AppLog.LogErrorAndExit(string.Format("bat参数错误,应该为形式如：a(b) 最少是4个字符，{0}", Arg));
}
AppLog.Log("检查完成，正确");
}
/// <summary>
/// 用于检查mapString型当逻辑上某列对应不同的类型取值时，其数据按是否要求含有或不允许有某些元素
/// </summary>
public static bool CheckMapString(FieldInfo fieldInfo, FieldCheckRule checkRule, out string errorString)
{
if (fieldInfo.DataType != DataType.MapString)
{
errorString = string.Format("mapString型的内容检查只适用于mapString类型的字段，要检查的这列类型为{0}\n", fieldInfo.DataType.ToString());
return(false);
}
MapStringCheckRule mapStringCheckRule = new MapStringCheckRule();
// 解析检查规则
const string CHECK_RULE_START_STRING = "mapString:";
string checkRuleString = null;
if (checkRule.CheckRuleString.Equals(CHECK_RULE_START_STRING, StringComparison.CurrentCultureIgnoreCase))
{
errorString = "mapString型的内容检查规则声明中必须含有具体的检查规则\n";
return(false);
}
else if (!checkRule.CheckRuleString.StartsWith(CHECK_RULE_START_STRING, StringComparison.CurrentCultureIgnoreCase))
{
errorString = string.Format("mapString型的内容检查规则声明错误，必须以\"{0}\"开头\n", CHECK_RULE_START_STRING);
return(false);
}
else
{
checkRuleString = checkRule.CheckRuleString.Substring(CHECK_RULE_START_STRING.Length).Trim();
}
// 通过|分隔不同条件下的内容检查规则
string[] checkRuleList = checkRuleString.Split(new string[] { "|" }, StringSplitOptions.RemoveEmptyEntries);
// 解析每一种条件下对应的mapString内容
for (int i = 0; i < checkRuleList.Length; ++i)
{
// 条件解析
MapStringCondition mapStringCondition = new MapStringCondition();
string oneCheckRule = checkRuleList[i].Trim();
string tempCheckRule = oneCheckRule;
if (string.IsNullOrEmpty(oneCheckRule))
{
errorString = "mapString型的内容检查规则声明错误，不允许含有空的规则声明，请检查是否含有多余的|分隔符\n";
return(false);
}
const string IF_CONDITION_START_STRING = "if(";
if (oneCheckRule.Equals(IF_CONDITION_START_STRING, StringComparison.CurrentCultureIgnoreCase) || !oneCheckRule.StartsWith(IF_CONDITION_START_STRING, StringComparison.CurrentCultureIgnoreCase))
{
errorString = string.Format("mapString型的内容检查规则声明错误，必须在if后面的括号中声明其他字段需满足的条件。若无要求，请填写为\"if(all)\"，你填写的为{0}\n", oneCheckRule);
return(false);
}
tempCheckRule = tempCheckRule.Substring(IF_CONDITION_START_STRING.Length);
int rightBracket = tempCheckRule.IndexOf(')');
if (rightBracket == -1)
{
errorString = string.Format("mapString型的内容检查规则声明错误，if后面的右括号缺失，你填写的为{0}\n", oneCheckRule);
return(false);
}
if (rightBracket == tempCheckRule.Length - 1)
{
errorString = string.Format("mapString型的内容检查规则声明错误，在if后面的括号中声明其他字段需满足的条件之后，还需在方括号内声明对mapString型下属字段的要求\n", oneCheckRule);
return(false);
}
string ifConditionString = tempCheckRule.Substring(0, rightBracket).Trim();
if (string.IsNullOrEmpty(ifConditionString))
{
errorString = "mapString型的内容检查规则声明错误，if后的括号中为空，若要设置为在任何条件下，请填写为\"if(all)\"\n";
return(false);
}
else if ("all".Equals(ifConditionString, StringComparison.CurrentCultureIgnoreCase))
{
Condition condition = new Condition();
condition.FieldInfo = null;
mapStringCondition.ConditionList.Add(condition);
}
else
{
// 通过英文逗号分隔要同时满足的条件
string[] ifConditionStringList = ifConditionString.Split(new string[] { "," }, StringSplitOptions.RemoveEmptyEntries);
for (int j = 0; j < ifConditionStringList.Length; j++)
{
Condition condition = new Condition();
string oneKeyValuePairString = ifConditionStringList[j].Trim();
string fieldName = null;
StringBuilder fieldNameBuilder = new StringBuilder();
int charIndex = 0;
bool isFoundSignOfRelation = false;
for (charIndex = 0; charIndex < oneKeyValuePairString.Length; ++charIndex)
{
char c = oneKeyValuePairString[charIndex];
if (c == '=' || c == '>' || c == '<')
{
fieldName = fieldNameBuilder.ToString().Trim();
isFoundSignOfRelation = true;
break;
}
else
{
fieldNameBuilder.Append(c);
}
}
if (string.IsNullOrEmpty(fieldName))
{
errorString = string.Format("mapString型的内容检查规则声明错误，if后的括号中（{0}）未声明字段名，请按字段名、关系符、取值的形式进行声明，如type>1\n", oneKeyValuePairString);
return(false);
}
else if (isFoundSignOfRelation == false)
{
errorString = string.Format("mapString型的内容检查规则声明错误，if后的括号中（{0}）未声明关系符，请按字段名、关系符、取值的形式进行声明，如type>1\n", oneKeyValuePairString);
return(false);
}
// 检查字段是否存在
FieldInfo targetFieldInfo = TableCheckHelper.GetFieldByIndexDefineString(fieldName, AppValues.TableInfo[fieldInfo.TableName], out errorString);
if (errorString != null)
{
errorString = string.Format("mapString型的内容检查规则声明错误，无法根据索引字符串\"{0}\"在表格{1}找到要对应的字段，错误信息为：{2}\n", fieldName, fieldInfo.TableName, errorString);
return(false);
}
// 检查字段类型是否符合要求
if (targetFieldInfo.DataType != DataType.Int && targetFieldInfo.DataType != DataType.Long && targetFieldInfo.DataType != DataType.Float && targetFieldInfo.DataType != DataType.Bool && targetFieldInfo.DataType != DataType.String)
{
errorString = string.Format("mapString型的内容检查规则声明错误，条件字段（{0}）的数据类型为{1}，而mapString型内容检查规则中，if条件字段只能为int、long、float、bool或string型\n", fieldName, targetFieldInfo.DataType);
return(false);
}
condition.FieldInfo = targetFieldInfo;
// 解析填写的关系符
string signOfRelation = null;
StringBuilder signOfRelationBuilder = new StringBuilder();
if (charIndex == oneKeyValuePairString.Length)
{
errorString = string.Format("mapString型的内容检查规则声明错误，if后的括号中（{0}）未声明取值，请按字段名、关系符、取值的形式进行声明，如type>1\n", oneKeyValuePairString);
return(false);
}
for (; charIndex < oneKeyValuePairString.Length; ++charIndex)
{
char c = oneKeyValuePairString[charIndex];
if (c == '=' || c == '>' || c == '<')
{
signOfRelationBuilder.Append(c);
}
else
{
break;
}
}
signOfRelation = signOfRelationBuilder.ToString();
if (signOfRelation == "=")
{
condition.Relation = Relation.Equal;
}
else if (signOfRelation == ">")
{
condition.Relation = Relation.GreaterThan;
}
else if (signOfRelation == ">=")
{
condition.Relation = Relation.GreaterThanOrEqual;
}
else if (signOfRelation == "<")
{
condition.Relation = Relation.LessThan;
}
else if (signOfRelation == "<=")
{
condition.Relation = Relation.LessThanOrEqual;
}
else
{
errorString = string.Format("mapString型的内容检查规则声明错误，关系符非法，只支持=、>、>=、<、<=，你填写的为{0}\n", oneKeyValuePairString);
return(false);
}
// bool、string型只有关系符=
if (condition.Relation != Relation.Equal && (targetFieldInfo.DataType == DataType.Bool || targetFieldInfo.DataType == DataType.String))
{
errorString = string.Format("mapString型的内容检查规则声明错误，条件字段（{0}）为{1}类型，只能进行等于判定，而你设置的关系符为{2}\n", fieldName, targetFieldInfo.DataType, condition.Relation);
return(false);
}
// 解析填写的取值
string valueString = oneKeyValuePairString.Substring(charIndex).Trim();
if (targetFieldInfo.DataType == DataType.Int)
{
int value = 0;
if (int.TryParse(valueString, out value) == false)
{
errorString = string.Format("mapString型的内容检查规则声明错误，条件字段（{0}）对应int型的取值（{1}）非法\n", fieldName, valueString);
return(false);
}
else
{
condition.Value = value;
}
}
else if (targetFieldInfo.DataType == DataType.Long)
{
long value = 0;
if (long.TryParse(valueString, out value) == false)
{
errorString = string.Format("mapString型的内容检查规则声明错误，条件字段（{0}）对应long型的取值（{1}）非法\n", fieldName, valueString);
return(false);
}
else
{
condition.Value = value;
}
}
else if (targetFieldInfo.DataType == DataType.Float)
{
double value = 0;
if (double.TryParse(valueString, out value) == false)
{
errorString = string.Format("mapString型的内容检查规则声明错误，条件字段（{0}）对应float型的取值（{1}）非法\n", fieldName, valueString);
return(false);
}
else
{
condition.Value = value;
}
}
else if (targetFieldInfo.DataType == DataType.Bool)
{
if ("1".Equals(valueString) || "true".Equals(valueString, StringComparison.CurrentCultureIgnoreCase))
{
condition.Value = true;
}
else if ("0".Equals(valueString) || "false".Equals(valueString, StringComparison.CurrentCultureIgnoreCase))
{
condition.Value = true;
}
else
{
errorString = string.Format("mapString型的内容检查规则声明错误，条件字段（{0}）对应bool型的取值（{1}）非法，bool型的值应用数字1、0或true、false进行声明\n", fieldName, valueString);
return(false);
}
}
else if (targetFieldInfo.DataType == DataType.String)
{
condition.Value = valueString;
}
else
{
errorString = "用CheckMapString函数处理非法的mapString型检查规则中定义的条件字段类型";
AppLog.LogErrorAndExit(errorString);
return(false);
}
mapStringCondition.ConditionList.Add(condition);
}
}
// mapString型下属字段要求解析
string mapStringRequiredString = tempCheckRule.Substring(rightBracket + 1).Trim();
if (!mapStringRequiredString.StartsWith("[") || !mapStringRequiredString.EndsWith("]"))
{
errorString = string.Format("mapString型的内容检查规则声明错误，每条检查规则中的字段要求声明必须在if条件声明后，在方括号内声明，你填写的为{0}\n", mapStringRequiredString);
return(false);
}
mapStringRequiredString = mapStringRequiredString.Substring(1, mapStringRequiredString.Length - 2).Trim();
MapStringRequiredInfo mapStringRequiredInfo = _GetMapStringRequiredInfo(mapStringRequiredString, fieldInfo, out errorString);
if (errorString != null)
{
errorString = string.Format("mapString型的内容检查规则声明错误，输入的字段要求错误，你填写的为\"{0}\"，错误原因为：{1}\n", mapStringRequiredString, errorString);
return(false);
}
else
{
mapStringCheckRule.CheckRuleList.Add(mapStringCondition, mapStringRequiredInfo);
}
}
// 按解析出的检查规则对mapString型进行检查
StringBuilder errorStringBuilder = new StringBuilder();
int ruleIndex = 0;
foreach (var item in mapStringCheckRule.CheckRuleList)
{
MapStringCondition condition = item.Key;
MapStringRequiredInfo requiredInfo = item.Value;
StringBuilder oneConditionStringBuilder = new StringBuilder();
// 先找出其他列满足检查条件的行
// 记录符合检查条件的数据索引值（从0计），这里先将所有数据行加入，然后逐步排除不满足条件的数据行
List <int> targetDataIndex = new List <int>();
int dataCount = fieldInfo.Data.Count;
for (int i = 0; i < dataCount; ++i)
{
targetDataIndex.Add(i);
}
List <int> emptyConditionRowIndex = new List <int>();
for (int conditionIndex = 0; conditionIndex < condition.ConditionList.Count; ++conditionIndex)
{
Condition oneCondition = condition.ConditionList[conditionIndex];
// 排除标为all的条件
if (oneCondition.FieldInfo != null)
{
List <int> tempEmptyConditionRowIndex = null;
_GetTargetDataIndex(oneCondition, targetDataIndex, oneCondition.FieldInfo, out tempEmptyConditionRowIndex);
if (tempEmptyConditionRowIndex != null && tempEmptyConditionRowIndex.Count > 0)
{
foreach (int rowIndex in tempEmptyConditionRowIndex)
{
if (!emptyConditionRowIndex.Contains(rowIndex))
{
emptyConditionRowIndex.Add(rowIndex);
}
}
}
}
}
if (emptyConditionRowIndex.Count > 0)
{
string warningString = string.Format("警告：mapString型字段\"{0}\"（列号：{1}）的检查条件（{2}）中的字段，因为以下行中数据无效，视为不满足条件，不对对应行中的mapString进行检查：{3}\n", fieldInfo.FieldName, ExcelMethods.GetExcelColumnName(fieldInfo.ColumnSeq + 1), checkRuleList[ruleIndex], Utils.CombineString(emptyConditionRowIndex, ","));
AppLog.LogWarning(warningString);
}
// 对满足检查条件的数据行进行mapString内容检查
List <int> emptyDataRowIndex = new List <int>();
foreach (int index in targetDataIndex)
{
// 若为空值，跳过检查，但进行警告
if (fieldInfo.Data[index] == null)
{
emptyDataRowIndex.Add(index + ExcelTableSetting.DataFieldDataStartRowIndex + 1);
continue;
}
JsonData jsonData = fieldInfo.Data[index] as JsonData;
if (_CheckMapStringData(jsonData, requiredInfo, out errorString) == false)
{
oneConditionStringBuilder.AppendFormat("第{0}行填写的数据（{1}）：\n{2}\n", index + ExcelTableSetting.DataFieldDataStartRowIndex + 1, fieldInfo.JsonString[index], errorString);
}
}
string oneConditionString = oneConditionStringBuilder.ToString();
if (!string.IsNullOrEmpty(oneConditionString))
{
errorStringBuilder.AppendFormat("以下行数据未通过检查规则\"{0}\"：\n{1}", checkRuleList[ruleIndex], oneConditionString);
}
if (emptyDataRowIndex.Count > 0)
{
string warningString = string.Format("警告：在对mapString型字段\"{0}\"（列号：{1}）执行检查条件（{2}）时，因为以下行中数据无效，跳过对mapString的检查：{3}\n", fieldInfo.FieldName, ExcelMethods.GetExcelColumnName(fieldInfo.ColumnSeq + 1), checkRuleList[ruleIndex], Utils.CombineString(emptyDataRowIndex, ","));
AppLog.LogWarning(warningString);
}
++ruleIndex;
}
errorString = errorStringBuilder.ToString();
if (string.IsNullOrEmpty(errorString))
{
errorString = null;
return(true);
}
else
{
return(false);
}
}
public static void ExportToMySQL()
{
string ExportType = "MySQL";
if (AppValues.ConfigData.ContainsKey("AllExport" + ExportType))
{
if (string.Equals("false", AppValues.ConfigData["AllExport" + ExportType].Trim().ToLower()))
{
return;
}
}
else
{
return;
}
string errorString = null;
BatExportPublicSetting batExportPublicSetting = new BatExportPublicSetting();
batExportPublicSetting.IsExport = false;
batExportPublicSetting.ExcelNameSplitString = "-";
batExportPublicSetting.ExportNameAfterLanguageMark = "";
batExportPublicSetting.GetParamValue();
BatExportSetting batExportSetting = new BatExportSetting();
batExportSetting.ExportTypeParam = "ExportMySQL";
batExportSetting.ExportPath = "";
batExportSetting.IsExport = false;
batExportSetting.IsExportKeepDirectoryStructure = false;
batExportSetting.ExportExtension = "";
batExportSetting.ExportNameBeforeAdd = "";
batExportSetting.IsExportNullNumber = false;
batExportSetting.IsExportNullString = false;//用于配置将表格导出到 MySQL 数据库时string 型字段中的空白单元格导出为数据库中的 NULL 而不是空字符串
batExportSetting.IsExportNullJson = false;
batExportSetting.IsExportNullArray = false;
batExportSetting.IsExportNullDict = false;
batExportSetting.IsExportNullBool = false;
batExportSetting.IsExportNullDate = false;
batExportSetting.IsExportNullTime = false;
batExportSetting.IsExportNullLang = false;
batExportSetting.IsExportFormat = false;
batExportSetting.IsExportFieldComment = false;
batExportSetting.ExportTopWords = "";
batExportSetting.ExportIndentationString = "";
batExportSetting.ExportSpaceString = "";
batExportSetting.IsExportJsonArrayFormat = false;
batExportSetting.IsExportJsonMapIncludeKeyColumnValue = false;
batExportSetting.IsArrayFieldName = false;
batExportSetting.IsTableNameStart = false;
batExportSetting.IsAddKeyToLuaTable = false;
batExportSetting.GetParamValue();
ConnectToDatabase(out errorString);
if (!string.IsNullOrEmpty(errorString))
{
AppLog.LogErrorAndExit(string.Format("无法连接至{0}数据库：{1}\n导出至{2}数据库被迫中止，请修正错误后重试\n", ExportType, errorString, ExportType));
}
foreach (KeyValuePair <string, TableInfo> kvp in AppValues.TableInfo)
{
TableInfo tableInfo = kvp.Value;
errorString = null;
ExcelConfigSetting excelConfigSetting = new ExcelConfigSetting();
excelConfigSetting.IsExportParam = "Export" + ExportType;
excelConfigSetting.ExportPathParam = ExportType + "ExportPath";
excelConfigSetting.IsExportKeepDirectoryStructureParam = ExportType + "IsExportKeepDirectoryStructure";
excelConfigSetting.ExportNameParam = ExportType + "ExportName";//用于配置当需要将表格导出到 MySQL 数据库时的表名
excelConfigSetting.ExcelNameSplitStringParam = ExportType + "ExcelNameSplitString";
excelConfigSetting.ExportExtensionParam = ExportType + "ExportExtension";
excelConfigSetting.ExportNameBeforeAddParam = ExportType + "ExportNameBeforeAdd";
excelConfigSetting.ExportNameAfterLanguageMarkParam = ExportType + "ExportNameAfterLanguageMark";
excelConfigSetting.IsExportNullNumberParam = ExportType + "IsExportNullNumber";
excelConfigSetting.IsExportNullStringParam = ExportType + "IsExportNullString";
excelConfigSetting.IsExportNullJsonParam = ExportType + "IsExportNullJson";
excelConfigSetting.IsExportNullArrayParam = ExportType + "IsExportNullArray";
excelConfigSetting.IsExportNullDictParam = ExportType + "IsExportNullDict";
excelConfigSetting.IsExportNullBoolParam = ExportType + "IsExportNullBool";
excelConfigSetting.IsExportNullDateParam = ExportType + "IsExportNullDate";
excelConfigSetting.IsExportNullTimeParam = ExportType + "IsExportNullTime";
excelConfigSetting.IsExportNullLangParam = ExportType + "IsExportNullLang";
excelConfigSetting.IsExportFormatParam = ExportType + "IsExportFormat";
excelConfigSetting.IsExportFieldCommentParam = ExportType + "ExportFieldComment";
excelConfigSetting.ExportTopWordsParam = ExportType + "ExportTopWords";//exportMySQLTableComment中声明某张表格导出到数据库中的说明信息
excelConfigSetting.ExportIndentationStringParam = ExportType + "ExportIndentationString";
excelConfigSetting.ExportSpaceStringParam = ExportType + "ExportSpaceString";
excelConfigSetting.IsExportJsonArrayFormatParam = ExportType + "IsExportJsonArrayFormat";
excelConfigSetting.IsExportJsonMapIncludeKeyColumnValueParam = ExportType + "IsExportJsonMapIncludeKeyColumnValue";
excelConfigSetting.IsArrayFieldNameParam = ExportType + "IsArrayFieldName";
excelConfigSetting.IsTableNameStartParam = ExportType + "IsTableNameStart";
excelConfigSetting.IsAddKeyToLuaTableParam = ExportType + "IsAddKeyToLuaTable";
excelConfigSetting.DateToExportFormatParam = ExportType + "DateToExportFormat";//日期导出的格式
excelConfigSetting.TimeToExportFormatParam = ExportType + "TimeToExportFormat";
excelConfigSetting.SpecialExportParam = "SpecialExport" + ExportType;
if (AppValues.ConfigData.ContainsKey("Export" + ExportType))
{
excelConfigSetting.IsExportParam = AppValues.ConfigData["Export" + ExportType].Trim();
}
if (AppValues.ConfigData.ContainsKey(ExportType + "ExportPath"))
{
excelConfigSetting.ExportPathParam = AppValues.ConfigData[ExportType + "ExportPath"].Trim();
}
if (AppValues.ConfigData.ContainsKey(ExportType + "IsExportKeepDirectoryStructure"))
{
excelConfigSetting.IsExportKeepDirectoryStructureParam = AppValues.ConfigData[ExportType + "IsExportKeepDirectoryStructure"].Trim();
}
if (AppValues.ConfigData.ContainsKey(ExportType + "ExportName"))
{
excelConfigSetting.ExportNameParam = AppValues.ConfigData[ExportType + "ExportName"].Trim();
}
if (AppValues.ConfigData.ContainsKey(ExportType + "ExcelNameSplitString"))
{
excelConfigSetting.ExcelNameSplitStringParam = AppValues.ConfigData[ExportType + "ExcelNameSplitString"].Trim();
}
if (AppValues.ConfigData.ContainsKey(ExportType + "ExportExtension"))
{
excelConfigSetting.ExportExtensionParam = AppValues.ConfigData[ExportType + "ExportExtension"].Trim();
}
if (AppValues.ConfigData.ContainsKey(ExportType + "ExportNameBeforeAdd"))
{
excelConfigSetting.ExportNameBeforeAddParam = AppValues.ConfigData[ExportType + "ExportNameBeforeAdd"].Trim();
}
if (AppValues.ConfigData.ContainsKey(ExportType + "ExportNameAfterLanguageMark"))
{
excelConfigSetting.ExportNameAfterLanguageMarkParam = AppValues.ConfigData[ExportType + "ExportNameAfterLanguageMark"].Trim();
}
if (AppValues.ConfigData.ContainsKey(ExportType + "IsExportNullNumber"))
{
excelConfigSetting.IsExportNullNumberParam = AppValues.ConfigData[ExportType + "IsExportNullNumber"].Trim();
}
if (AppValues.ConfigData.ContainsKey(ExportType + "IsExportNullString"))
{
excelConfigSetting.IsExportNullStringParam = AppValues.ConfigData[ExportType + "IsExportNullString"].Trim();
}
if (AppValues.ConfigData.ContainsKey(ExportType + "IsExportNullJson"))
{
excelConfigSetting.IsExportNullJsonParam = AppValues.ConfigData[ExportType + "IsExportNullJson"].Trim();
}
if (AppValues.ConfigData.ContainsKey(ExportType + "IsExportNullArray"))
{
excelConfigSetting.IsExportNullArrayParam = AppValues.ConfigData[ExportType + "IsExportNullArray"].Trim();
}
if (AppValues.ConfigData.ContainsKey(ExportType + "IsExportNullDict"))
{
excelConfigSetting.IsExportNullDictParam = AppValues.ConfigData[ExportType + "IsExportNullDict"].Trim();
}
if (AppValues.ConfigData.ContainsKey(ExportType + "IsExportNullBool"))
{
excelConfigSetting.IsExportNullBoolParam = AppValues.ConfigData[ExportType + "IsExportNullBool"].Trim();
}
if (AppValues.ConfigData.ContainsKey(ExportType + "IsExportNullDate"))
{
excelConfigSetting.IsExportNullDateParam = AppValues.ConfigData[ExportType + "IsExportNullDate"].Trim();
}
if (AppValues.ConfigData.ContainsKey(ExportType + "IsExportNullTime"))
{
excelConfigSetting.IsExportNullTimeParam = AppValues.ConfigData[ExportType + "IsExportNullTime"].Trim();
}
if (AppValues.ConfigData.ContainsKey(ExportType + "IsExportNullLang"))
{
excelConfigSetting.IsExportNullLangParam = AppValues.ConfigData[ExportType + "IsExportNullLang"].Trim();
}
if (AppValues.ConfigData.ContainsKey(ExportType + "IsExportFormat"))
{
excelConfigSetting.IsExportFormatParam = AppValues.ConfigData[ExportType + "IsExportFormat"].Trim();
}
if (AppValues.ConfigData.ContainsKey(ExportType + "ExportFieldComment"))
{
excelConfigSetting.IsExportFieldCommentParam = AppValues.ConfigData[ExportType + "ExportFieldComment"].Trim();
}
if (AppValues.ConfigData.ContainsKey(ExportType + "ExportTopWords"))
{
excelConfigSetting.ExportTopWordsParam = AppValues.ConfigData[ExportType + "ExportTopWords"].Trim();
}
if (AppValues.ConfigData.ContainsKey(ExportType + "ExportIndentationString"))
{
excelConfigSetting.ExportIndentationStringParam = AppValues.ConfigData[ExportType + "ExportIndentationString"].Trim();
}
if (AppValues.ConfigData.ContainsKey(ExportType + "ExportSpaceString"))
{
excelConfigSetting.ExportSpaceStringParam = AppValues.ConfigData[ExportType + "ExportSpaceString"].Trim();
}
if (AppValues.ConfigData.ContainsKey(ExportType + "ExportLineString"))
{
excelConfigSetting.ExportLineStringParam = AppValues.ConfigData[ExportType + "ExportLineString"].Trim();
}
if (AppValues.ConfigData.ContainsKey(ExportType + "IsExportJsonArrayFormat"))
{
excelConfigSetting.IsExportJsonArrayFormatParam = AppValues.ConfigData[ExportType + "IsExportJsonArrayFormat"].Trim();
}
if (AppValues.ConfigData.ContainsKey(ExportType + "IsExportJsonMapIncludeKeyColumnValue"))
{
excelConfigSetting.IsExportJsonMapIncludeKeyColumnValueParam = AppValues.ConfigData[ExportType + "IsExportJsonMapIncludeKeyColumnValue"].Trim();
}
if (AppValues.ConfigData.ContainsKey(ExportType + "IsArrayFieldName"))
{
excelConfigSetting.IsArrayFieldNameParam = AppValues.ConfigData[ExportType + "IsArrayFieldName"].Trim();
}
if (AppValues.ConfigData.ContainsKey(ExportType + "IsTableNameStart"))
{
excelConfigSetting.IsTableNameStartParam = AppValues.ConfigData[ExportType + "IsTableNameStart"].Trim();
}
if (AppValues.ConfigData.ContainsKey(ExportType + "IsAddKeyToLuaTable"))
{
excelConfigSetting.IsAddKeyToLuaTableParam = AppValues.ConfigData[ExportType + "IsAddKeyToLuaTable"].Trim();
}
if (AppValues.ConfigData.ContainsKey(ExportType + "DateToExportFormat"))
{
excelConfigSetting.DateToExportFormatParam = AppValues.ConfigData[ExportType + "DateToExportFormat"].Trim();
}
if (AppValues.ConfigData.ContainsKey(ExportType + "TimeToExportFormat"))
{
excelConfigSetting.TimeToExportFormatParam = AppValues.ConfigData[ExportType + "TimeToExportFormat"].Trim();
}
excelConfigSetting.GetParamValue(tableInfo);
Export export = new Export();
export.GetValue(tableInfo, excelConfigSetting, batExportSetting, batExportPublicSetting);
// export.GetExportName(excelConfigSetting.ExportName, tableInfo.ExcelName, export.ExcelNameSplitString);
string m = "";
if (AppValues.MergeTableList != null && AppValues.MergeTableList.ContainsKey(kvp.Key) && batExportSetting.IsExport == true)
{
export.IsExport = true;
export.ExportName = kvp.Key;
m = "[合并]";
}
if (export.IsExport == true)
{
AppLog.Log(string.Format("\n开始{0}导入{1}：数据库", m, ExportType), ConsoleColor.Green, false);
AppLog.Log(string.Format("{0}并命名为{1}", tableInfo.ExcelNameTips, export.ExportName), ConsoleColor.Green);
ExportTableToDatabase(tableInfo, export, out errorString);
if (!string.IsNullOrEmpty(errorString))
{
AppLog.LogErrorAndExit(string.Format("导出失败：{0}\n导出至{1}数据库被迫中止，请修正错误后重试\n", errorString, ExportType));
}
}
}
}