private static bool _CreateTable(string tableName, TableInfo tableInfo, out string errorString)
{
// 生成在创建数据表时所有字段的声明
StringBuilder fieldDefineStringBuilder = new StringBuilder();
foreach (FieldInfo fieldInfo in GetAllDatabaseFieldInfo(tableInfo))
{
// 在这里并不对每种本工具的数据类型是否能导出为指定的MySQL数据类型进行检查（比如本工具中的string型应该导出为MySQL中的文本类型如varchar，而不应该导出为数值类型）
if (fieldInfo.DataType == DataType.Date)
{
string toDatabaseFormatDefine = fieldInfo.ExtraParam[AppValues.TABLE_INFO_EXTRA_PARAM_KEY_DATE_TO_DATABASE_FORMAT].ToString();
DateFormatType toDatabaseFormatType = TableAnalyzeHelper.GetDateFormatType(toDatabaseFormatDefine);
if (fieldInfo.DatabaseFieldType.StartsWith("time", StringComparison.CurrentCultureIgnoreCase))
{
errorString = string.Format("date型字段\"{0}\"（列号：{1}）声明导出到MySQL中的数据类型错误，不允许为time型，如果仅需要时分秒部分，请在Excel中将该字段在本工具中的数据类型改为time型", fieldInfo.FieldName, Utils.GetExcelColumnName(fieldInfo.ColumnSeq + 1));
return(false);
}
if (toDatabaseFormatType == DateFormatType.ReferenceDateSec || toDatabaseFormatType == DateFormatType.ReferenceDateMsec)
{
if (fieldInfo.DatabaseFieldType.StartsWith("datetime", StringComparison.CurrentCultureIgnoreCase) || fieldInfo.DatabaseFieldType.Equals("date", StringComparison.CurrentCultureIgnoreCase))
{
errorString = string.Format("date型字段\"{0}\"（列号：{1}）声明导出到MySQL中的形式为距1970年的时间（{2}），但所填写的导出到MySQL中的格式为时间型的{3}，请声明为MySQL中的数值型", fieldInfo.FieldName, Utils.GetExcelColumnName(fieldInfo.ColumnSeq + 1), toDatabaseFormatDefine, fieldInfo.DatabaseFieldType);
return(false);
}
}
}
else if (fieldInfo.DataType == DataType.Time)
{
string toDatabaseFormatDefine = fieldInfo.ExtraParam[AppValues.TABLE_INFO_EXTRA_PARAM_KEY_TIME_TO_DATABASE_FORMAT].ToString();
TimeFormatType toDatabaseFormatType = TableAnalyzeHelper.GetTimeFormatType(toDatabaseFormatDefine);
if (fieldInfo.DatabaseFieldType.StartsWith("datetime", StringComparison.CurrentCultureIgnoreCase) || fieldInfo.DatabaseFieldType.Equals("date", StringComparison.CurrentCultureIgnoreCase))
{
errorString = string.Format("time型字段\"{0}\"（列号：{1}）声明导出到MySQL中的数据类型错误，不允许为datetime或date型，如果需要年月日部分，请在Excel中将该字段在本工具中的数据类型改为date型", fieldInfo.FieldName, Utils.GetExcelColumnName(fieldInfo.ColumnSeq + 1));
return(false);
}
if (toDatabaseFormatType == TimeFormatType.ReferenceTimeSec && fieldInfo.DatabaseFieldType.StartsWith("time", StringComparison.CurrentCultureIgnoreCase))
{
errorString = string.Format("time型字段\"{0}\"（列号：{1}）声明导出到MySQL中的形式为距0点的秒数（#sec），但所填写的导出到MySQL中的格式为时间型的time，请声明为MySQL中的数值型", fieldInfo.FieldName, Utils.GetExcelColumnName(fieldInfo.ColumnSeq + 1));
return(false);
}
}
fieldDefineStringBuilder.AppendFormat("`{0}` {1} COMMENT '{2}',", fieldInfo.DatabaseFieldName, fieldInfo.DatabaseFieldType, fieldInfo.Desc);
}
string createTableSql = string.Format(_CREATE_TABLE_SQL, _CombineDatabaseTableFullName(tableName), fieldDefineStringBuilder.ToString(), tableInfo.GetKeyColumnFieldInfo().DatabaseFieldName);
try
{
MySqlCommand cmd = new MySqlCommand(createTableSql, _conn);
cmd.ExecuteNonQuery();
errorString = null;
return(true);
}
catch (MySqlException exception)
{
errorString = exception.Message;
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成功");
}
}
}
}
private static string _GetTimeValue(FieldInfo fieldInfo, int row, int level)
{
StringBuilder content = new StringBuilder();
TimeFormatType timeFormatType = TableAnalyzeHelper.GetTimeFormatType(fieldInfo.ExtraParam[AppValues.TABLE_INFO_EXTRA_PARAM_KEY_TIME_TO_LUA_FORMAT].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[AppValues.TABLE_INFO_EXTRA_PARAM_KEY_TIME_TO_LUA_FORMAT].ToString())).Append("\"");
}
break;
}
case TimeFormatType.ReferenceTimeSec:
{
if (fieldInfo.Data[row] == null)
{
content.Append("nil");
}
else
{
content.Append(((DateTime)(fieldInfo.Data[row]) - AppValues.REFERENCE_DATE).TotalSeconds);
}
break;
}
default:
{
Utils.LogErrorAndExit("错误：用_GetTimeValue函数导出lua文件的time型的TimeFormatType非法");
break;
}
}
return(content.ToString());
}
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>
/// 检查date型的输入格式定义
/// </summary>
public static bool CheckDateInputDefine(string defineString, out string errorString)
{
defineString = defineString.Trim();
if (string.IsNullOrEmpty(defineString))
{
errorString = "未进行格式声明";
return(false);
}
DateFormatType formatType = TableAnalyzeHelper.GetDateFormatType(defineString);
if (!(formatType == DateFormatType.FormatString || formatType == DateFormatType.ReferenceDateMsec || formatType == DateFormatType.ReferenceDateSec))
{
errorString = "不属于合法的date型输入格式类型";
return(false);
}
errorString = null;
return(true);
}
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成功");
}
}
}
}
private void btnAnalyze_Click(object sender, EventArgs e)
{
string inputFormatString = tbFormat.Text.Trim();
string inputDataString = tbData.Text;
if (string.IsNullOrEmpty(inputFormatString))
{
MessageBox.Show("未输入格式定义", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
if (string.IsNullOrEmpty(inputDataString))
{
MessageBox.Show("未输入数据", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
// 解析格式定义
string errorString = null;
TableStringFormatDefine formatDefine = TableAnalyzeHelper.GetTableStringFormatDefine(inputFormatString, out errorString);
if (errorString != null)
{
tbOutput.Text = "格式声明错误，" + errorString;
return;
}
// 生成lua table
string exportString = TableExportToLuaHelper.GetTableStringValue(formatDefine, inputDataString, 0, out errorString);
if (errorString != null)
{
tbOutput.Text = "输入数据错误，" + errorString;
}
else
{
tbOutput.Text = exportString;
}
}
/// <summary>
/// 检查time型的格式定义
/// </summary>
public static bool CheckTimeDefine(string defineString, out string errorString)
{
defineString = defineString.Trim();
if (string.IsNullOrEmpty(defineString))
{
errorString = "未进行格式声明";
return(false);
}
TimeFormatType formatType = TableAnalyzeHelper.GetTimeFormatType(defineString);
if (formatType == TimeFormatType.FormatString)
{
// 检查time型的格式字符串声明，不允许出现代表年月日的y、M、d
List <string> errorInfo = new List <string>();
if (defineString.IndexOf('y') != -1)
{
errorInfo.Add("代表年的y");
}
if (defineString.IndexOf('M') != -1)
{
errorInfo.Add("代表月的M");
}
if (defineString.IndexOf('d') != -1)
{
errorInfo.Add("代表日的d");
}
if (errorInfo.Count > 0)
{
errorString = string.Format("time类型的格式定义中不允许出现以下与年月日相关的日期型格式定义字符：{0}", Utils.CombineString(errorInfo, "，"));
return(false);
}
}
errorString = null;
return(true);
}
/// <summary>
/// 传入参数中，第1个必须为Excel表格所在目录，第2个必须为存放导出lua文件的目录，第3个参数为项目Client目录的路径（无需文件存在型检查规则则填-noClient），第4个参数为必须为lang文件路径（没有填-noLang）
/// 可附加参数为：-columnInfo（在生成lua文件的最上方用注释形式显示列信息，默认不开启），-unchecked（不对表格进行查错，不推荐使用），-printEmptyStringWhenLangNotMatching（当lang型数据key在lang文件中找不到对应值时，在lua文件输出字段值为空字符串即xx = ""，默认为输出nil）
/// </summary>
static void Main(string[] args)
{
// 检查第1个参数（Excel表格所在目录）是否正确
if (args.Length < 1)
{
Utils.LogErrorAndExit("错误：未输入Excel表格所在目录");
}
if (!Directory.Exists(args[0]))
{
Utils.LogErrorAndExit(string.Format("错误：输入的Excel表格所在目录不存在，路径为{0}", args[0]));
}
AppValues.ExcelFolderPath = Path.GetFullPath(args[0]);
Utils.Log(string.Format("选择的Excel所在路径：{0}", AppValues.ExcelFolderPath));
// 检查第2个参数（存放导出lua文件的目录）是否正确
if (args.Length < 2)
{
Utils.LogErrorAndExit("错误：未输入要将生成lua文件存放的路径");
}
if (!Directory.Exists(args[1]))
{
Utils.LogErrorAndExit(string.Format("错误：输入的lua文件导出路径不存在，路径为{0}", args[1]));
}
AppValues.ExportLuaFilePath = Path.GetFullPath(args[1]);
Utils.Log(string.Format("选择的lua文件导出路径：{0}", AppValues.ExportLuaFilePath));
// 检查第3个参数（项目Client目录的路径）是否正确
if (args.Length < 3)
{
Utils.LogErrorAndExit("错误：未输入项目Client目录的路径，如果不需要请输入参数-noClient");
}
if (AppValues.NO_CLIENT_PATH_STRING.Equals(args[2], StringComparison.CurrentCultureIgnoreCase))
{
Utils.LogWarning("警告：你选择了不指定Client文件夹路径，则本工具无法检查表格中填写的图片路径等对应的文件是否存在");
AppValues.ClientPath = null;
}
else if (Directory.Exists(args[2]))
{
AppValues.ClientPath = Path.GetFullPath(args[2]);
Utils.Log(string.Format("Client目录完整路径：{0}", AppValues.ClientPath));
}
else
{
Utils.LogErrorAndExit(string.Format("错误：请检查输入的Client路径是否正确{0}", args[2]));
}
// 检查第4个参数（lang文件路径）是否正确
if (args.Length < 4)
{
Utils.LogErrorAndExit("错误：未输入lang文件路径或未声明不含lang文件（使用-noLang）");
}
if (AppValues.NO_LONG_PARAM_STRING.Equals(args[3], StringComparison.CurrentCultureIgnoreCase))
{
AppValues.LangFilePath = null;
Utils.Log("选择的lang文件路径：无");
}
else if (File.Exists(args[3]))
{
AppValues.LangFilePath = Path.GetFullPath(args[3]);
Utils.Log(string.Format("选择的lang文件路径：{0}", AppValues.LangFilePath));
// 解析lang文件
string errorString = null;
AppValues.LangData = TxtConfigReader.ParseTxtConfigFile(AppValues.LangFilePath, ":", out errorString);
if (!string.IsNullOrEmpty(errorString))
{
Utils.LogErrorAndExit(errorString);
}
}
else
{
Utils.LogErrorAndExit(string.Format("错误：输入的lang文件不存在，路径为{0}", args[3]));
}
// 检查其他参数
for (int i = 4; i < args.Length; ++i)
{
string param = args[i];
switch (param)
{
case AppValues.UNCHECKED_PARAM_STRING:
{
AppValues.IsNeedCheck = false;
Utils.LogWarning("警告：你选择了不进行表格检查，请务必自己保证表格的正确性");
break;
}
case AppValues.NEED_COLUMN_INFO_PARAM_STRING:
{
AppValues.IsNeedColumnInfo = true;
Utils.LogWarning("你选择了在生成的lua文件最上方用注释形式显示列信息");
break;
}
case AppValues.LANG_NOT_MATCHING_PRINT_PARAM_STRING:
{
AppValues.IsPrintEmptyStringWhenLangNotMatching = true;
Utils.LogWarning("你选择了当lang型数据key在lang文件中找不到对应值时，在lua文件输出字段值为空字符串");
break;
}
default:
{
Utils.LogErrorAndExit(string.Format("错误：未知的指令参数{0}", param));
break;
}
}
}
// 解析本工具所在目录下的config文件
if (File.Exists(AppValues.CONFIG_FILE_NAME))
{
string errorString = null;
AppValues.ConfigData = TxtConfigReader.ParseTxtConfigFile(AppValues.CONFIG_FILE_NAME, ":", out errorString);
if (!string.IsNullOrEmpty(errorString))
{
Utils.LogErrorAndExit(errorString);
}
}
else
{
Utils.LogWarning(string.Format("警告：找不到本工具所在路径下的{0}配置文件，请确定是否真的不需要自定义配置", AppValues.CONFIG_FILE_NAME));
}
// 读取给定的Excel所在目录下的所有Excel文件，然后解析成本程序所需的数据结构
foreach (var filePath in Directory.GetFiles(AppValues.ExcelFolderPath, "*.xlsx"))
{
string errorString = null;
DataTable dt = XlsxReader.ReadXlsxFile(filePath, out errorString);
if (string.IsNullOrEmpty(errorString))
{
string fileName = Path.GetFileNameWithoutExtension(filePath);
TableInfo tableInfo = TableAnalyzeHelper.AnalyzeTable(dt, fileName, out errorString);
if (errorString != null)
{
Utils.LogErrorAndExit(string.Format("错误：解析{0}失败\n{1}", filePath, errorString));
}
else
{
AppValues.TableInfo.Add(tableInfo.TableName, tableInfo);
}
}
else
{
Utils.LogErrorAndExit(string.Format("错误：读取{0}失败\n{1}", filePath, errorString));
}
}
// 进行表格检查
bool isTableAllRight = true;
if (AppValues.IsNeedCheck == true)
{
Utils.Log("\n下面开始进行表格检查：");
foreach (TableInfo tableInfo in AppValues.TableInfo.Values)
{
string errorString = null;
Utils.Log(string.Format("检查表格\"{0}\"：", tableInfo.TableName));
TableCheckHelper.CheckTable(tableInfo, out errorString);
if (errorString != null)
{
Utils.LogError(errorString);
isTableAllRight = false;
}
else
{
Utils.Log("正确");
}
}
}
if (isTableAllRight == true)
{
Utils.Log("\n表格检查完毕，没有发现错误，开始导出为lua文件\n");
// 进行表格导出
foreach (TableInfo tableInfo in AppValues.TableInfo.Values)
{
string errorString = null;
TableExportToLuaHelper.ExportTableToLua(tableInfo, out errorString);
if (errorString != null)
{
Utils.LogErrorAndExit(errorString);
}
}
Utils.Log("\n导出lua文件完毕\n");
}
else
{
Utils.LogError("\n表格检查完毕，但存在上面所列错误，必须全部修正后才可以进行表格导出\n");
// 将错误信息全部输出保存到txt文件中
Utils.SaveErrorInfoToFile();
}
Utils.Log("\n按任意键退出本程序");
Console.ReadKey();
}
private static string _GetDateValue(FieldInfo fieldInfo, int row, int level)
{
StringBuilder content = new StringBuilder();
DateFormatType dateFormatType = TableAnalyzeHelper.GetDateFormatType(fieldInfo.ExtraParam[AppValues.TABLE_INFO_EXTRA_PARAM_KEY_DATE_TO_LUA_FORMAT].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[AppValues.TABLE_INFO_EXTRA_PARAM_KEY_DATE_TO_LUA_FORMAT].ToString())).Append("\"");
}
break;
}
case DateFormatType.ReferenceDateSec:
{
if (fieldInfo.Data[row] == null)
{
content.Append("nil");
}
else
{
content.Append(((DateTime)(fieldInfo.Data[row]) - AppValues.REFERENCE_DATE_LOCAL).TotalSeconds);
}
break;
}
case DateFormatType.ReferenceDateMsec:
{
if (fieldInfo.Data[row] == null)
{
content.Append("nil");
}
else
{
content.Append(((DateTime)(fieldInfo.Data[row]) - AppValues.REFERENCE_DATE_LOCAL).TotalMilliseconds);
}
break;
}
case DateFormatType.DataTable:
{
if (fieldInfo.Data[row] == null)
{
content.Append("nil");
}
else
{
double totalSeconds = ((DateTime)(fieldInfo.Data[row]) - AppValues.REFERENCE_DATE_LOCAL).TotalSeconds;
content.Append("os.date(\"!*t\", ").Append(totalSeconds).Append(")");
}
break;
}
default:
{
Utils.LogErrorAndExit("错误：用_GetDateValue函数导出lua文件的date型的DateFormatType非法");
break;
}
}
return(content.ToString());
}
private static string _GetDateValue(FieldInfo fieldInfo, int row)
{
StringBuilder content = new StringBuilder();
DateFormatType dateFormatType = TableAnalyzeHelper.GetDateFormatType(fieldInfo.ExtraParam[AppValues.TABLE_INFO_EXTRA_PARAM_KEY_DATE_TO_LUA_FORMAT].ToString());
string exportFormatString = null;
// 若date型声明toLua的格式为dateTable，则按input格式进行导出
if (dateFormatType == DateFormatType.DataTable)
{
dateFormatType = TableAnalyzeHelper.GetDateFormatType(fieldInfo.ExtraParam[AppValues.TABLE_INFO_EXTRA_PARAM_KEY_DATE_INPUT_FORMAT].ToString());
exportFormatString = fieldInfo.ExtraParam[AppValues.TABLE_INFO_EXTRA_PARAM_KEY_DATE_INPUT_FORMAT].ToString();
}
else
{
exportFormatString = fieldInfo.ExtraParam[AppValues.TABLE_INFO_EXTRA_PARAM_KEY_DATE_TO_LUA_FORMAT].ToString();
}
switch (dateFormatType)
{
case DateFormatType.FormatString:
{
if (fieldInfo.Data[row] == null)
{
content.Append("null");
}
else
{
content.Append("\"").Append(((DateTime)(fieldInfo.Data[row])).ToString(exportFormatString)).Append("\"");
}
break;
}
case DateFormatType.ReferenceDateSec:
{
if (fieldInfo.Data[row] == null)
{
content.Append("null");
}
else
{
content.Append(((DateTime)(fieldInfo.Data[row]) - AppValues.REFERENCE_DATE).TotalSeconds);
}
break;
}
case DateFormatType.ReferenceDateMsec:
{
if (fieldInfo.Data[row] == null)
{
content.Append("null");
}
else
{
content.Append(((DateTime)(fieldInfo.Data[row]) - AppValues.REFERENCE_DATE).TotalMilliseconds);
}
break;
}
default:
{
Utils.LogErrorAndExit("错误：用_GetDateValue函数导出json文件的date型的DateFormatType非法");
break;
}
}
return(content.ToString());
}
private static bool _InsertData(string tableName, TableInfo tableInfo, 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, ", ");
// 用户是否配置该表中string型字段中的空单元格导出至MySQL中为NULL，默认为空字符串
bool isWriteNullForEmptyString = tableInfo.TableConfig != null && tableInfo.TableConfig.ContainsKey(AppValues.CONFIG_NAME_EXPORT_DATABASE_WRITE_NULL_FOR_EMPTY_STRING) && tableInfo.TableConfig[AppValues.CONFIG_NAME_EXPORT_DATABASE_WRITE_NULL_FOR_EMPTY_STRING].Count > 0 && "true".Equals(tableInfo.TableConfig[AppValues.CONFIG_NAME_EXPORT_DATABASE_WRITE_NULL_FOR_EMPTY_STRING][0], StringComparison.CurrentCultureIgnoreCase);
// 逐行生成插入数据的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[AppValues.TABLE_INFO_EXTRA_PARAM_KEY_DATE_TO_DATABASE_FORMAT].ToString();
DateFormatType toDatabaseFormatType = TableAnalyzeHelper.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(AppValues.APP_DEFAULT_ONLY_DATE_FORMAT)));
}
else if (fieldInfo.DatabaseFieldType.StartsWith("datetime", StringComparison.CurrentCultureIgnoreCase))
{
values.Add(string.Format("'{0}'", ((DateTime)(fieldInfo.Data[i])).ToString(AppValues.APP_DEFAULT_DATE_FORMAT)));
}
// date型导出到MySQL中的其他数据类型字段如varchar，采用声明的指定格式
else
{
values.Add(string.Format("'{0}'", ((DateTime)(fieldInfo.Data[i])).ToString(fieldInfo.ExtraParam[AppValues.TABLE_INFO_EXTRA_PARAM_KEY_DATE_TO_DATABASE_FORMAT].ToString())));
}
}
else if (toDatabaseFormatType == DateFormatType.ReferenceDateSec)
{
values.Add(string.Format("'{0}'", ((DateTime)fieldInfo.Data[i] - AppValues.REFERENCE_DATE_LOCAL).TotalSeconds));
}
else if (toDatabaseFormatType == DateFormatType.ReferenceDateMsec)
{
values.Add(string.Format("'{0}'", ((DateTime)fieldInfo.Data[i] - AppValues.REFERENCE_DATE_LOCAL).TotalMilliseconds));
}
else
{
errorString = "date型导出至MySQL的格式定义非法";
Utils.LogErrorAndExit(errorString);
return(false);
}
}
else if (fieldInfo.DataType == DataType.Time)
{
string toDatabaseFormatDefine = fieldInfo.ExtraParam[AppValues.TABLE_INFO_EXTRA_PARAM_KEY_TIME_TO_DATABASE_FORMAT].ToString();
TimeFormatType toDatabaseFormatType = TableAnalyzeHelper.GetTimeFormatType(toDatabaseFormatDefine);
if (toDatabaseFormatType == TimeFormatType.FormatString)
{
if (fieldInfo.DatabaseFieldType.StartsWith("time", StringComparison.CurrentCultureIgnoreCase))
{
values.Add(string.Format("'{0}'", ((DateTime)(fieldInfo.Data[i])).ToString(AppValues.APP_DEFAULT_TIME_FORMAT)));
}
else
{
values.Add(string.Format("'{0}'", ((DateTime)(fieldInfo.Data[i])).ToString(fieldInfo.ExtraParam[AppValues.TABLE_INFO_EXTRA_PARAM_KEY_TIME_TO_DATABASE_FORMAT].ToString())));
}
}
else if (toDatabaseFormatType == TimeFormatType.ReferenceTimeSec)
{
values.Add(string.Format("'{0}'", ((DateTime)fieldInfo.Data[i] - AppValues.REFERENCE_DATE).TotalSeconds));
}
else
{
errorString = "time型导出至MySQL的格式定义非法";
Utils.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(_INSERT_DATA_SQL, _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);
}
}
public static void ExportToLua(TableInfo tableInfo)
{
string errorString = null;
if (LuaStruct.ExportLuaIsFormat == false)
{
LuaStruct.IndentationString = "";
}
// 判断是否设置要是否要导出null字段
TableAnalyzeHelper.GetOneConfigData(tableInfo, LuaStruct.Excel_Config_NotExportLuaNil, ref LuaStruct.IsExportLuaNilConfig);
//if (tableInfo.TableConfig != null && tableInfo.TableConfig.ContainsKey(LuaStruct.Excel_Config_NotExportLuaNil))
//{
// if (tableInfo.TableConfig[LuaStruct.Excel_Config_NotExportLuaNil].Count > 0)
// {
// if ("false".Equals(tableInfo.TableConfig[LuaStruct.Excel_Config_NotExportLuaNil][0], StringComparison.CurrentCultureIgnoreCase))
// {
// LuaStruct.IsExportLuaNilConfig = false;
// }
// }
//}
// 以下为旧的代码。判断是否设置了特殊导出规则
if (tableInfo.TableConfigData2 != null && tableInfo.TableConfigData2.ContainsKey("tableExportConfig"))
{
List <string> inputParams = tableInfo.TableConfigData2[LuaStruct.Excel_Config_SpecialExportLua];
if (inputParams.Contains(LuaStruct.Excel_Config_NotExportLuaOriginalTable))
{
LuaStruct.IsExportLua = false;
if (inputParams.Count == 1)
{
AppLog.LogWarning(string.Format("警告：你设置了不对表格\"{0}\"按默认方式进行导出Lua，而又没有指定任何其他自定义导出规则，本工具对此表格不进行任何导出，请确认是否真要如此", tableInfo.TableName));
}
else
{
AppLog.Log("你设置了不对此表进行默认规则导出Lua");
}
}
// 执行设置的特殊导出规则
foreach (string param in inputParams)
{
if (!LuaStruct.Excel_Config_NotExportLuaOriginalTable.Equals(param, StringComparison.CurrentCultureIgnoreCase))
{
AppLog.Log(string.Format("对此表格按\"{0}\"自定义规则进行导出Lua：", param));
TableExportToLuaHelper.SpecialExportTableToLua(tableInfo, param, out errorString);
if (errorString != null)
{
AppLog.LogErrorAndExit(string.Format("导出特殊lua失败：\n{0}\n", errorString));
}
else
{
AppLog.Log("导出特殊lua成功");
}
}
}
}
//以下为新的代码
if (TableAnalyzeHelper.GetOneConfigData(tableInfo, LuaStruct.Excel_Config_SpecialExportLua, ref LuaStruct.SpecialExportLuaParams))
{
// 特殊嵌套导出
foreach (string param in LuaStruct.SpecialExportLuaParams)
{
AppLog.Log(string.Format("对此表格按\"{0}\"自定义规则进行导出Lua：", param));
TableExportToLuaHelper.SpecialExportTableToLua(tableInfo, param, out errorString);
if (errorString != null)
{
AppLog.LogErrorAndExit(string.Format("导出特殊lua失败：\n{0}\n", errorString));
}
else
{
AppLog.Log("导出特殊lua成功");
}
}
}
if (TableAnalyzeHelper.GetOneConfigData(tableInfo, LuaStruct.Excel_Config_ExportLua, ref LuaStruct.IsExportLua))
{
// 对表格按默认方式导出
if (LuaStruct.IsExportLua == true)
{
TableExportToLuaHelper.ExportTableToLua(tableInfo, out errorString);
if (errorString != null)
{
AppLog.LogErrorAndExit(errorString);
}
else
{
AppLog.Log("按默认方式导出lua成功");
}
}
}
else
{
// 对表格按默认方式导出
if (LuaStruct.IsExport == true)
{
TableExportToLuaHelper.ExportTableToLua(tableInfo, out errorString);
if (errorString != null)
{
AppLog.LogErrorAndExit(errorString);
}
else
{
AppLog.Log("按默认方式导出lua成功");
}
}
}
}
/// <summary>
/// 传入参数中，第1个必须为Excel表格所在目录，第2个必须为存放导出lua文件的目录，第3个参数为项目Client目录的路径（无需文件存在型检查规则则填-noClient），第4个参数为必须为lang文件路径（没有填-noLang）
/// 可附加参数有：
/// 1) -columnInfo（在生成lua文件的最上方用注释形式显示列信息，默认不开启）
/// 2) -unchecked（不对表格进行查错，不推荐使用）
/// 3) -printEmptyStringWhenLangNotMatching（当lang型数据key在lang文件中找不到对应值时，在lua文件输出字段值为空字符串即xx = ""，默认为输出nil）
/// 4) -exportMySQL（将表格数据导出到MySQL数据库中，默认不导出）
/// 5) -part（后面在英文小括号内声明本次要导出的Excel文件名，用|分隔，未声明的文件将被本工具忽略）
/// </summary>
static void Main(string[] args)
{
// 检查第1个参数（Excel表格所在目录）是否正确
if (args.Length < 1)
{
Utils.LogErrorAndExit("错误：未输入Excel表格所在目录");
}
if (!Directory.Exists(args[0]))
{
Utils.LogErrorAndExit(string.Format("错误：输入的Excel表格所在目录不存在，路径为{0}", args[0]));
}
AppValues.ExcelFolderPath = Path.GetFullPath(args[0]);
Utils.Log(string.Format("选择的Excel所在路径：{0}", AppValues.ExcelFolderPath));
// 检查第2个参数（存放导出lua文件的目录）是否正确
if (args.Length < 2)
{
Utils.LogErrorAndExit("错误：未输入要将生成lua文件存放的路径");
}
if (!Directory.Exists(args[1]))
{
Utils.LogErrorAndExit(string.Format("错误：输入的lua文件导出路径不存在，路径为{0}", args[1]));
}
AppValues.ExportLuaFilePath = Path.GetFullPath(args[1]);
Utils.Log(string.Format("选择的lua文件导出路径：{0}", AppValues.ExportLuaFilePath));
// 检查第3个参数（项目Client目录的路径）是否正确
if (args.Length < 3)
{
Utils.LogErrorAndExit("错误：未输入项目Client目录的路径，如果不需要请输入参数-noClient");
}
if (AppValues.NO_CLIENT_PATH_STRING.Equals(args[2], StringComparison.CurrentCultureIgnoreCase))
{
Utils.LogWarning("警告：你选择了不指定Client文件夹路径，则本工具无法检查表格中填写的图片路径等对应的文件是否存在");
AppValues.ClientPath = null;
}
else if (Directory.Exists(args[2]))
{
AppValues.ClientPath = Path.GetFullPath(args[2]);
Utils.Log(string.Format("Client目录完整路径：{0}", AppValues.ClientPath));
}
else
{
Utils.LogErrorAndExit(string.Format("错误：请检查输入的Client路径是否正确{0}", args[2]));
}
// 检查第4个参数（lang文件路径）是否正确
if (args.Length < 4)
{
Utils.LogErrorAndExit("错误：未输入lang文件路径或未声明不含lang文件（使用-noLang）");
}
if (AppValues.NO_LANG_PARAM_STRING.Equals(args[3], StringComparison.CurrentCultureIgnoreCase))
{
AppValues.LangFilePath = null;
Utils.Log("选择的lang文件路径：无");
}
else if (File.Exists(args[3]))
{
AppValues.LangFilePath = Path.GetFullPath(args[3]);
Utils.Log(string.Format("选择的lang文件路径：{0}", AppValues.LangFilePath));
// 解析lang文件
string errorString = null;
AppValues.LangData = TxtConfigReader.ParseTxtConfigFile(AppValues.LangFilePath, ":", out errorString);
if (!string.IsNullOrEmpty(errorString))
{
Utils.LogErrorAndExit(errorString);
}
}
else
{
Utils.LogErrorAndExit(string.Format("错误：输入的lang文件不存在，路径为{0}", args[3]));
}
// 检查其他参数
for (int i = 4; i < args.Length; ++i)
{
string param = args[i];
if (param.Equals(AppValues.UNCHECKED_PARAM_STRING, StringComparison.CurrentCultureIgnoreCase))
{
AppValues.IsNeedCheck = false;
Utils.LogWarning("警告：你选择了不进行表格检查，请务必自己保证表格的正确性");
}
else if (param.Equals(AppValues.NEED_COLUMN_INFO_PARAM_STRING, StringComparison.CurrentCultureIgnoreCase))
{
AppValues.IsNeedColumnInfo = true;
Utils.LogWarning("你选择了在生成的lua文件最上方用注释形式显示列信息");
}
else if (param.Equals(AppValues.LANG_NOT_MATCHING_PRINT_PARAM_STRING, StringComparison.CurrentCultureIgnoreCase))
{
AppValues.IsPrintEmptyStringWhenLangNotMatching = true;
Utils.LogWarning("你选择了当lang型数据key在lang文件中找不到对应值时，在lua文件输出字段值为空字符串");
}
else if (param.Equals(AppValues.EXPORT_MYSQL_PARAM_STRING, StringComparison.CurrentCultureIgnoreCase))
{
AppValues.IsExportMySQL = true;
Utils.LogWarning("你选择了导出表格数据到MySQL数据库");
}
else if (param.StartsWith(AppValues.PART_EXPORT_PARAM_STRING, StringComparison.CurrentCultureIgnoreCase))
{
// 解析声明的本次要导出的Excel名
int leftBracketIndex = param.IndexOf('(');
int rightBracketIndex = param.LastIndexOf(')');
if (leftBracketIndex == -1 || rightBracketIndex == -1 || leftBracketIndex > rightBracketIndex)
{
Utils.LogErrorAndExit(string.Format("错误：声明导出部分Excel表格的参数{0}后必须在英文小括号内声明Excel文件名", AppValues.PART_EXPORT_PARAM_STRING));
}
else
{
string fileNameString = param.Substring(leftBracketIndex + 1, rightBracketIndex - leftBracketIndex - 1).Trim();
string[] fileNames = fileNameString.Split(new char[] { '|' }, StringSplitOptions.RemoveEmptyEntries);
if (fileNames.Length < 1)
{
Utils.LogErrorAndExit(string.Format("错误：声明导出部分Excel表格的参数{0}后必须在英文小括号内声明至少一个Excel文件名", AppValues.PART_EXPORT_PARAM_STRING));
}
foreach (string fileName in fileNames)
{
AppValues.exportTableNames.Add(fileName.Trim());
}
// 检查指定导出的Excel文件是否存在（注意不能直接用File.Exists判断是否存在，因为Windows会忽略声明的Excel文件名与实际文件名的大小写差异）
List <string> existExcelFilePaths = new List <string>(Directory.GetFiles(AppValues.ExcelFolderPath, "*.xlsx"));
List <string> existExcelFileNames = new List <string>();
foreach (string filePath in existExcelFilePaths)
{
existExcelFileNames.Add(Path.GetFileNameWithoutExtension(filePath));
}
foreach (string exportExcelFileName in AppValues.exportTableNames)
{
if (!existExcelFileNames.Contains(exportExcelFileName))
{
Utils.LogErrorAndExit(string.Format("要求导出的Excel文件（{0}）不存在，请检查后重试并注意区分大小写", Utils.CombinePath(AppValues.ExcelFolderPath, string.Concat(exportExcelFileName, ".xlsx"))));
}
}
Utils.LogWarning(string.Format("警告：本次将仅检查并导出以下Excel文件：\n{0}\n", Utils.CombineString(AppValues.exportTableNames, ", ")));
}
}
else if (param.StartsWith(AppValues.ALLOWED_NULL_NUMBER_PARAM_STRING, StringComparison.CurrentCultureIgnoreCase))
{
AppValues.IsAllowedNullNumber = true;
Utils.LogWarning("警告：你选择了允许int、long、float字段中存在空值，建议为逻辑上不允许为空的数值型字段声明使用notEmpty检查规则");
}
else
{
Utils.LogErrorAndExit(string.Format("错误：未知的指令参数{0}", param));
}
}
// 如果未指定导出部分Excel文件，则全部导出
if (AppValues.exportTableNames.Count == 0)
{
foreach (string filePath in Directory.GetFiles(AppValues.ExcelFolderPath, "*.xlsx"))
{
AppValues.exportTableNames.Add(Path.GetFileNameWithoutExtension(filePath));
}
}
// 解析本工具所在目录下的config文件
string configFilePath = Utils.CombinePath(AppValues.PROGRAM_FOLDER_PATH, AppValues.CONFIG_FILE_NAME);
if (File.Exists(configFilePath))
{
string errorString = null;
AppValues.ConfigData = TxtConfigReader.ParseTxtConfigFile(configFilePath, ":", out errorString);
if (!string.IsNullOrEmpty(errorString))
{
Utils.LogErrorAndExit(errorString);
}
}
else
{
Utils.LogWarning(string.Format("警告：找不到本工具所在路径下的{0}配置文件，请确定是否真的不需要自定义配置", AppValues.CONFIG_FILE_NAME));
}
// 读取部分配置项并进行检查
const string ERROR_STRING_FORMAT = "配置项\"{0}\"所设置的值\"{1}\"非法：{2}\n";
StringBuilder errorStringBuilder = new StringBuilder();
string tempErrorString = null;
if (AppValues.ConfigData.ContainsKey(AppValues.APP_CONFIG_KEY_DEFAULT_DATE_INPUT_FORMAT))
{
AppValues.DefaultDateInputFormat = AppValues.ConfigData[AppValues.APP_CONFIG_KEY_DEFAULT_DATE_INPUT_FORMAT].Trim();
if (TableCheckHelper.CheckDateInputDefine(AppValues.DefaultDateInputFormat, out tempErrorString) == false)
{
errorStringBuilder.AppendFormat(ERROR_STRING_FORMAT, AppValues.APP_CONFIG_KEY_DEFAULT_DATE_INPUT_FORMAT, AppValues.DefaultDateInputFormat, tempErrorString);
}
}
if (AppValues.ConfigData.ContainsKey(AppValues.APP_CONFIG_KEY_DEFAULT_DATE_TO_LUA_FORMAT))
{
AppValues.DefaultDateToLuaFormat = AppValues.ConfigData[AppValues.APP_CONFIG_KEY_DEFAULT_DATE_TO_LUA_FORMAT].Trim();
if (TableCheckHelper.CheckDateToLuaDefine(AppValues.DefaultDateToLuaFormat, out tempErrorString) == false)
{
errorStringBuilder.AppendFormat(ERROR_STRING_FORMAT, AppValues.APP_CONFIG_KEY_DEFAULT_DATE_TO_LUA_FORMAT, AppValues.DefaultDateToLuaFormat, tempErrorString);
}
}
if (AppValues.ConfigData.ContainsKey(AppValues.APP_CONFIG_KEY_DEFAULT_DATE_TO_DATABASE_FORMAT))
{
AppValues.DefaultDateToDatabaseFormat = AppValues.ConfigData[AppValues.APP_CONFIG_KEY_DEFAULT_DATE_TO_DATABASE_FORMAT].Trim();
if (TableCheckHelper.CheckDateToDatabaseDefine(AppValues.DefaultDateToDatabaseFormat, out tempErrorString) == false)
{
errorStringBuilder.AppendFormat(ERROR_STRING_FORMAT, AppValues.APP_CONFIG_KEY_DEFAULT_DATE_TO_DATABASE_FORMAT, AppValues.DefaultDateToDatabaseFormat, tempErrorString);
}
}
if (AppValues.ConfigData.ContainsKey(AppValues.APP_CONFIG_KEY_DEFAULT_TIME_INPUT_FORMAT))
{
AppValues.DefaultTimeInputFormat = AppValues.ConfigData[AppValues.APP_CONFIG_KEY_DEFAULT_TIME_INPUT_FORMAT].Trim();
if (TableCheckHelper.CheckTimeDefine(AppValues.DefaultTimeInputFormat, out tempErrorString) == false)
{
errorStringBuilder.AppendFormat(ERROR_STRING_FORMAT, AppValues.APP_CONFIG_KEY_DEFAULT_TIME_INPUT_FORMAT, AppValues.DefaultTimeInputFormat, tempErrorString);
}
}
if (AppValues.ConfigData.ContainsKey(AppValues.APP_CONFIG_KEY_DEFAULT_TIME_TO_LUA_FORMAT))
{
AppValues.DefaultTimeToLuaFormat = AppValues.ConfigData[AppValues.APP_CONFIG_KEY_DEFAULT_TIME_TO_LUA_FORMAT].Trim();
if (TableCheckHelper.CheckTimeDefine(AppValues.DefaultTimeToLuaFormat, out tempErrorString) == false)
{
errorStringBuilder.AppendFormat(ERROR_STRING_FORMAT, AppValues.APP_CONFIG_KEY_DEFAULT_TIME_TO_LUA_FORMAT, AppValues.DefaultTimeToLuaFormat, tempErrorString);
}
}
if (AppValues.ConfigData.ContainsKey(AppValues.APP_CONFIG_KEY_DEFAULT_TIME_TO_DATABASE_FORMAT))
{
AppValues.DefaultTimeToDatabaseFormat = AppValues.ConfigData[AppValues.APP_CONFIG_KEY_DEFAULT_TIME_TO_DATABASE_FORMAT].Trim();
if (TableCheckHelper.CheckTimeDefine(AppValues.DefaultTimeToDatabaseFormat, out tempErrorString) == false)
{
errorStringBuilder.AppendFormat(ERROR_STRING_FORMAT, AppValues.APP_CONFIG_KEY_DEFAULT_TIME_TO_DATABASE_FORMAT, AppValues.DefaultTimeToDatabaseFormat, tempErrorString);
}
}
// 读取给定的Excel所在目录下的所有Excel文件，然后解析成本工具所需的数据结构
foreach (string filePath in Directory.GetFiles(AppValues.ExcelFolderPath, "*.xlsx"))
{
string errorString = null;
DataSet ds = XlsxReader.ReadXlsxFile(filePath, out errorString);
if (string.IsNullOrEmpty(errorString))
{
string fileName = Path.GetFileNameWithoutExtension(filePath);
TableInfo tableInfo = TableAnalyzeHelper.AnalyzeTable(ds.Tables[AppValues.EXCEL_DATA_SHEET_NAME], fileName, out errorString);
if (errorString != null)
{
Utils.LogErrorAndExit(string.Format("错误：解析{0}失败\n{1}", filePath, errorString));
}
else
{
// 如果有表格配置进行解析
if (ds.Tables[AppValues.EXCEL_CONFIG_SHEET_NAME] != null)
{
tableInfo.TableConfig = TableAnalyzeHelper.GetTableConfig(ds.Tables[AppValues.EXCEL_CONFIG_SHEET_NAME], out errorString);
if (!string.IsNullOrEmpty(errorString))
{
Utils.LogErrorAndExit(string.Format("错误：解析表格{0}的配置失败\n{1}", fileName, errorString));
}
}
AppValues.TableInfo.Add(tableInfo.TableName, tableInfo);
}
}
else
{
Utils.LogErrorAndExit(string.Format("错误：读取{0}失败\n{1}", filePath, errorString));
}
}
// 进行表格检查
bool isTableAllRight = true;
if (AppValues.IsNeedCheck == true)
{
Utils.Log("\n下面开始进行表格检查：");
foreach (string tableName in AppValues.exportTableNames)
{
TableInfo tableInfo = AppValues.TableInfo[tableName];
string errorString = null;
Utils.Log(string.Format("检查表格\"{0}\"：", tableInfo.TableName));
TableCheckHelper.CheckTable(tableInfo, out errorString);
if (errorString != null)
{
Utils.LogError(errorString);
isTableAllRight = false;
}
else
{
Utils.Log("正确");
}
}
}
if (isTableAllRight == true)
{
Utils.Log("\n表格检查完毕，没有发现错误，开始导出为lua文件\n");
// 进行表格导出
foreach (string tableName in AppValues.exportTableNames)
{
TableInfo tableInfo = AppValues.TableInfo[tableName];
string errorString = null;
Utils.Log(string.Format("导出表格\"{0}\"：", tableInfo.TableName));
bool isNeedExportOriginalTable = true;
// 判断是否设置了特殊导出规则
if (tableInfo.TableConfig != null && tableInfo.TableConfig.ContainsKey(AppValues.CONFIG_NAME_EXPORT))
{
List <string> inputParams = tableInfo.TableConfig[AppValues.CONFIG_NAME_EXPORT];
if (inputParams.Contains(AppValues.CONFIG_PARAM_NOT_EXPORT_ORIGINAL_TABLE))
{
isNeedExportOriginalTable = false;
if (inputParams.Count == 1)
{
Utils.LogWarning(string.Format("警告：你设置了不对表格\"{0}\"按默认方式进行导出，而又没有指定任何其他自定义导出规则，本工具对此表格不进行任何导出，请确认是否真要如此", tableInfo.TableName));
}
else
{
Utils.Log("你设置了不对此表进行默认规则导出");
}
}
// 执行设置的特殊导出规则
foreach (string param in inputParams)
{
if (!AppValues.CONFIG_PARAM_NOT_EXPORT_ORIGINAL_TABLE.Equals(param, StringComparison.CurrentCultureIgnoreCase))
{
Utils.Log(string.Format("对此表格按\"{0}\"自定义规则进行导出：", param));
TableExportToLuaHelper.SpecialExportTableToLua(tableInfo, param, out errorString);
if (errorString != null)
{
Utils.LogErrorAndExit(string.Format("导出失败：\n{0}\n", errorString));
}
else
{
Utils.Log("成功");
}
}
}
}
// 对表格按默认方式导出（除非通过参数设置不执行此操作）
if (isNeedExportOriginalTable == true)
{
TableExportToLuaHelper.ExportTableToLua(tableInfo, out errorString);
if (errorString != null)
{
Utils.LogErrorAndExit(errorString);
}
else
{
Utils.Log("按默认方式导出成功");
}
}
}
Utils.Log("\n导出lua文件完毕\n");
// 进行数据库导出
if (AppValues.IsExportMySQL == true)
{
Utils.Log("\n导出表格数据到MySQL数据库\n");
string errorString = null;
TableExportToMySQLHelper.ConnectToDatabase(out errorString);
if (!string.IsNullOrEmpty(errorString))
{
Utils.LogErrorAndExit(string.Format("无法连接至MySQL数据库：{0}\n导出至MySQL数据库被迫中止，请修正错误后重试\n", errorString));
}
foreach (string tableName in AppValues.exportTableNames)
{
TableInfo tableInfo = AppValues.TableInfo[tableName];
TableExportToMySQLHelper.ExportTableToDatabase(tableInfo, out errorString);
if (!string.IsNullOrEmpty(errorString))
{
Utils.LogErrorAndExit(string.Format("导出失败：{0}\n导出至MySQL数据库被迫中止，请修正错误后重试\n", errorString));
}
}
Utils.Log("\n导出到数据库完毕\n");
}
}
else
{
Utils.LogError("\n表格检查完毕，但存在上面所列错误，必须全部修正后才可以进行表格导出\n");
// 将错误信息全部输出保存到txt文件中
Utils.SaveErrorInfoToFile();
}
Utils.Log("\n按任意键退出本工具");
Console.ReadKey();
}
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());
}
private static bool _InsertData(string tableName, TableInfo tableInfo, 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, ", ");
// 逐行生成插入数据的SQL语句中的value定义部分
StringBuilder valueDefineStringBuilder = new StringBuilder();
int count = tableInfo.GetKeyColumnFieldInfo().Data.Count;
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[AppValues.TABLE_INFO_EXTRA_PARAM_KEY_DATE_TO_DATABASE_FORMAT].ToString();
DateFormatType toDatabaseFormatType = TableAnalyzeHelper.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(AppValues.APP_DEFAULT_ONLY_DATE_FORMAT)));
}
else if (fieldInfo.DatabaseFieldType.StartsWith("datetime", StringComparison.CurrentCultureIgnoreCase))
{
values.Add(string.Format("'{0}'", ((DateTime)(fieldInfo.Data[i])).ToString(AppValues.APP_DEFAULT_DATE_FORMAT)));
}
// date型导出到MySQL中的其他数据类型字段如varchar，采用声明的指定格式
else
{
values.Add(string.Format("'{0}'", ((DateTime)(fieldInfo.Data[i])).ToString(fieldInfo.ExtraParam[AppValues.TABLE_INFO_EXTRA_PARAM_KEY_DATE_TO_DATABASE_FORMAT].ToString())));
}
}
else if (toDatabaseFormatType == DateFormatType.ReferenceDateSec)
{
values.Add(string.Format("'{0}'", ((DateTime)fieldInfo.Data[i] - AppValues.REFERENCE_DATE).TotalSeconds));
}
else if (toDatabaseFormatType == DateFormatType.ReferenceDateMsec)
{
values.Add(string.Format("'{0}'", ((DateTime)fieldInfo.Data[i] - AppValues.REFERENCE_DATE).TotalMilliseconds));
}
else
{
errorString = "date型导出至MySQL的格式定义非法";
Utils.LogErrorAndExit(errorString);
return(false);
}
}
else if (fieldInfo.DataType == DataType.Time)
{
string toDatabaseFormatDefine = fieldInfo.ExtraParam[AppValues.TABLE_INFO_EXTRA_PARAM_KEY_TIME_TO_DATABASE_FORMAT].ToString();
TimeFormatType toDatabaseFormatType = TableAnalyzeHelper.GetTimeFormatType(toDatabaseFormatDefine);
if (toDatabaseFormatType == TimeFormatType.FormatString)
{
if (fieldInfo.DatabaseFieldType.StartsWith("time", StringComparison.CurrentCultureIgnoreCase))
{
values.Add(string.Format("'{0}'", ((DateTime)(fieldInfo.Data[i])).ToString(AppValues.APP_DEFAULT_TIME_FORMAT)));
}
else
{
values.Add(string.Format("'{0}'", ((DateTime)(fieldInfo.Data[i])).ToString(fieldInfo.ExtraParam[AppValues.TABLE_INFO_EXTRA_PARAM_KEY_TIME_TO_DATABASE_FORMAT].ToString())));
}
}
else if (toDatabaseFormatType == TimeFormatType.ReferenceTimeSec)
{
values.Add(string.Format("'{0}'", ((DateTime)fieldInfo.Data[i] - AppValues.REFERENCE_DATE).TotalSeconds));
}
else
{
errorString = "time型导出至MySQL的格式定义非法";
Utils.LogErrorAndExit(errorString);
return(false);
}
}
// 这里需要自行处理向数据库中某些数据类型如datetime的列不允许插入空字符串的情况
else if (string.IsNullOrEmpty(fieldInfo.Data[i].ToString()))
{
if (fieldInfo.DatabaseFieldType.StartsWith("datetime", StringComparison.CurrentCultureIgnoreCase))
{
values.Add("NULL");
}
else
{
values.Add(string.Format("'{0}'", fieldInfo.Data[i].ToString()));
}
}
else if (fieldInfo.DataType == DataType.Bool)
{
string inputData = fieldInfo.Data[i].ToString();
// 如果数据库用tinyint(1)数据类型表示bool型，比如要写入true，SQL语句中可以写为'1'或者不带单引号的true
if ("true".Equals(inputData, StringComparison.CurrentCultureIgnoreCase))
{
values.Add("'1'");
}
else if ("false".Equals(inputData, StringComparison.CurrentCultureIgnoreCase))
{
values.Add("'0'");
}
else
{
values.Add(string.Format("'{0}'", fieldInfo.Data[i].ToString()));
}
}
else
{
values.Add(string.Format("'{0}'", fieldInfo.Data[i].ToString()));
}
}
valueDefineStringBuilder.AppendFormat("({0}),", Utils.CombineString(values, ","));
}
// 去掉末尾多余的逗号
string valueDefineString = valueDefineStringBuilder.ToString();
valueDefineString = valueDefineString.Substring(0, valueDefineString.Length - 1);
string insertSqlString = string.Format(_INSERT_DATA_SQL, _CombineDatabaseTableFullName(tableName), fieldNameDefineString, valueDefineString);
// 执行插入操作
try
{
MySqlCommand cmd = new MySqlCommand(insertSqlString, _conn);
int insertCount = cmd.ExecuteNonQuery();
if (insertCount < count)
{
errorString = string.Format("需要插入{0}条数据但仅插入了{1}条");
return(false);
}
else
{
errorString = null;
return(true);
}
}
catch (MySqlException exception)
{
errorString = exception.Message;
return(false);
}
}
private static void _GetOneFieldCsvContent(FieldInfo fieldInfo, List <StringBuilder> rowContentList)
{
int rowCount = fieldInfo.Data.Count;
switch (fieldInfo.DataType)
{
case DataType.Int:
case DataType.Long:
case DataType.Float:
case DataType.String:
case DataType.Lang:
case DataType.TableString:
{
for (int row = 0; row < rowCount; ++row)
{
StringBuilder stringBuilder = rowContentList[row];
// 先增加与上一字段间的分隔符
stringBuilder.Append(AppValues.ExportCsvSplitString);
// 再生成本行对应的内容
if (fieldInfo.Data[row] != null)
{
stringBuilder.Append(fieldInfo.Data[row].ToString());
}
}
break;
}
case DataType.Bool:
{
for (int row = 0; row < rowCount; ++row)
{
StringBuilder stringBuilder = rowContentList[row];
stringBuilder.Append(AppValues.ExportCsvSplitString);
if (fieldInfo.Data[row] != null)
{
if ((bool)fieldInfo.Data[row] == true)
{
stringBuilder.Append("true");
}
else
{
stringBuilder.Append("false");
}
}
}
break;
}
case DataType.Json:
{
for (int row = 0; row < rowCount; ++row)
{
StringBuilder stringBuilder = rowContentList[row];
stringBuilder.Append(AppValues.ExportCsvSplitString);
if (fieldInfo.Data[row] != null)
{
stringBuilder.Append(fieldInfo.JsonString[row]);
}
}
break;
}
case DataType.MapString:
{
for (int row = 0; row < rowCount; ++row)
{
StringBuilder stringBuilder = rowContentList[row];
stringBuilder.Append(AppValues.ExportCsvSplitString);
if (fieldInfo.Data[row] != null)
{
stringBuilder.Append(fieldInfo.JsonString[row]);
}
}
break;
}
case DataType.Date:
{
DateFormatType dateFormatType = TableAnalyzeHelper.GetDateFormatType(fieldInfo.ExtraParam[AppValues.TABLE_INFO_EXTRA_PARAM_KEY_DATE_TO_LUA_FORMAT].ToString());
string exportFormatString = null;
// 若date型声明toLua的格式为dateTable，则按input格式进行导出
if (dateFormatType == DateFormatType.DataTable)
{
dateFormatType = TableAnalyzeHelper.GetDateFormatType(fieldInfo.ExtraParam[AppValues.TABLE_INFO_EXTRA_PARAM_KEY_DATE_INPUT_FORMAT].ToString());
exportFormatString = fieldInfo.ExtraParam[AppValues.TABLE_INFO_EXTRA_PARAM_KEY_DATE_INPUT_FORMAT].ToString();
}
else
{
exportFormatString = fieldInfo.ExtraParam[AppValues.TABLE_INFO_EXTRA_PARAM_KEY_DATE_TO_LUA_FORMAT].ToString();
}
switch (dateFormatType)
{
case DateFormatType.FormatString:
{
for (int row = 0; row < rowCount; ++row)
{
StringBuilder stringBuilder = rowContentList[row];
stringBuilder.Append(AppValues.ExportCsvSplitString);
if (fieldInfo.Data[row] != null)
{
stringBuilder.Append(((DateTime)(fieldInfo.Data[row])).ToString(exportFormatString));
}
}
break;
}
case DateFormatType.ReferenceDateSec:
{
for (int row = 0; row < rowCount; ++row)
{
StringBuilder stringBuilder = rowContentList[row];
stringBuilder.Append(AppValues.ExportCsvSplitString);
if (fieldInfo.Data[row] != null)
{
stringBuilder.Append(((DateTime)(fieldInfo.Data[row]) - AppValues.REFERENCE_DATE_LOCAL).TotalSeconds);
}
}
break;
}
case DateFormatType.ReferenceDateMsec:
{
for (int row = 0; row < rowCount; ++row)
{
StringBuilder stringBuilder = rowContentList[row];
stringBuilder.Append(AppValues.ExportCsvSplitString);
if (fieldInfo.Data[row] != null)
{
stringBuilder.Append(((DateTime)(fieldInfo.Data[row]) - AppValues.REFERENCE_DATE_LOCAL).TotalMilliseconds);
}
}
break;
}
default:
{
Utils.LogErrorAndExit("用_GetOneFieldCsvContent函数导出csv文件的date型的DateFormatType非法");
break;
}
}
break;
}
case DataType.Time:
{
TimeFormatType timeFormatType = TableAnalyzeHelper.GetTimeFormatType(fieldInfo.ExtraParam[AppValues.TABLE_INFO_EXTRA_PARAM_KEY_TIME_TO_LUA_FORMAT].ToString());
switch (timeFormatType)
{
case TimeFormatType.FormatString:
{
for (int row = 0; row < rowCount; ++row)
{
StringBuilder stringBuilder = rowContentList[row];
stringBuilder.Append(AppValues.ExportCsvSplitString);
if (fieldInfo.Data[row] != null)
{
stringBuilder.Append(((DateTime)(fieldInfo.Data[row])).ToString(fieldInfo.ExtraParam[AppValues.TABLE_INFO_EXTRA_PARAM_KEY_TIME_TO_LUA_FORMAT].ToString()));
}
}
break;
}
case TimeFormatType.ReferenceTimeSec:
{
for (int row = 0; row < rowCount; ++row)
{
StringBuilder stringBuilder = rowContentList[row];
stringBuilder.Append(AppValues.ExportCsvSplitString);
if (fieldInfo.Data[row] != null)
{
stringBuilder.Append(((DateTime)(fieldInfo.Data[row]) - AppValues.REFERENCE_DATE).TotalSeconds);
}
}
break;
}
default:
{
Utils.LogErrorAndExit("错误：用_GetOneFieldCsvContent函数导出csv文件的time型的TimeFormatType非法");
break;
}
}
break;
}
case DataType.Array:
case DataType.Dict:
{
for (int row = 0; row < rowCount; ++row)
{
StringBuilder stringBuilder = rowContentList[row];
stringBuilder.Append(AppValues.ExportCsvSplitString);
if ((bool)fieldInfo.Data[row] == false)
{
stringBuilder.Append("-1");
}
}
break;
}
default:
{
Utils.LogErrorAndExit(string.Format("_GetOneFieldCsvContent函数中未定义{0}类型数据导出至csv文件的形式", fieldInfo.DataType));
break;
}
}
}
private static void _GetOneFieldTxtContent(FieldInfo fieldInfo, List <StringBuilder> rowContentList)
{
int rowCount = fieldInfo.Data.Count;
switch (fieldInfo.DataType)
{
case DataType.Int:
case DataType.Long:
case DataType.Float:
case DataType.String:
{
for (int row = 0; row < rowCount; ++row)
{
StringBuilder stringBuilder = rowContentList[row];
// 先增加与上一字段间的分隔符
stringBuilder.Append(TxtStruct.ExportSpaceString);
// 再生成本行对应的内容
if (fieldInfo.Data[row] != null)
{
stringBuilder.Append(fieldInfo.Data[row].ToString().Replace("\n", "\\n"));
}
}
break;
}
case DataType.Lang:
case DataType.TableString:
{
for (int row = 0; row < rowCount; ++row)
{
StringBuilder stringBuilder = rowContentList[row];
// 先增加与上一字段间的分隔符
stringBuilder.Append(TxtStruct.ExportSpaceString);
// 再生成本行对应的内容
if (fieldInfo.Data[row] != null)
{
stringBuilder.Append(fieldInfo.Data[row].ToString().Replace("\n", "\\n"));
}
}
break;
}
case DataType.Bool:
{
for (int row = 0; row < rowCount; ++row)
{
StringBuilder stringBuilder = rowContentList[row];
stringBuilder.Append(TxtStruct.ExportSpaceString);
if (fieldInfo.Data[row] != null)
{
if ((bool)fieldInfo.Data[row] == true)
{
stringBuilder.Append("true");
}
else
{
stringBuilder.Append("false");
}
}
}
break;
}
case DataType.Json:
{
for (int row = 0; row < rowCount; ++row)
{
StringBuilder stringBuilder = rowContentList[row];
stringBuilder.Append(TxtStruct.ExportSpaceString);
if (fieldInfo.Data[row] != null)
{
stringBuilder.Append(fieldInfo.JsonString[row]);
}
}
break;
}
case DataType.Date:
{
DateFormatType dateFormatType = TableAnalyzeHelper.GetDateFormatType(fieldInfo.ExtraParam[DateTimeValue.DateInputFormat].ToString());
string exportFormatString = null;
// 若date型声明toLua的格式为dateTable，则按input格式进行导出
if (dateFormatType == DateFormatType.DataTable)
{
dateFormatType = TableAnalyzeHelper.GetDateFormatType(fieldInfo.ExtraParam[DateTimeValue.DateInputFormat].ToString());
exportFormatString = fieldInfo.ExtraParam[DateTimeValue.DateInputFormat].ToString();
}
else
{
exportFormatString = fieldInfo.ExtraParam[DateTimeValue.DateInputFormat].ToString();
}
switch (dateFormatType)
{
case DateFormatType.FormatString:
{
for (int row = 0; row < rowCount; ++row)
{
StringBuilder stringBuilder = rowContentList[row];
stringBuilder.Append(TxtStruct.ExportSpaceString);
if (fieldInfo.Data[row] != null)
{
stringBuilder.Append(((DateTime)(fieldInfo.Data[row])).ToString(exportFormatString));
}
}
break;
}
case DateFormatType.ReferenceDateSec:
{
for (int row = 0; row < rowCount; ++row)
{
StringBuilder stringBuilder = rowContentList[row];
stringBuilder.Append(TxtStruct.ExportSpaceString);
if (fieldInfo.Data[row] != null)
{
stringBuilder.Append(((DateTime)(fieldInfo.Data[row]) - DateTimeValue.REFERENCE_DATE).TotalSeconds);
}
}
break;
}
case DateFormatType.ReferenceDateMsec:
{
for (int row = 0; row < rowCount; ++row)
{
StringBuilder stringBuilder = rowContentList[row];
stringBuilder.Append(TxtStruct.ExportSpaceString);
if (fieldInfo.Data[row] != null)
{
stringBuilder.Append(((DateTime)(fieldInfo.Data[row]) - DateTimeValue.REFERENCE_DATE).TotalMilliseconds);
}
}
break;
}
default:
{
AppLog.LogErrorAndExit("用_GetOneFieldTxtContent函数导出txt文件的date型的DateFormatType非法");
break;
}
}
break;
}
case DataType.Time:
{
TimeFormatType timeFormatType = TableAnalyzeHelper.GetTimeFormatType(fieldInfo.ExtraParam[DateTimeValue.TimeInputFormat].ToString());
switch (timeFormatType)
{
case TimeFormatType.FormatString:
{
for (int row = 0; row < rowCount; ++row)
{
StringBuilder stringBuilder = rowContentList[row];
stringBuilder.Append(TxtStruct.ExportSpaceString);
if (fieldInfo.Data[row] != null)
{
stringBuilder.Append(((DateTime)(fieldInfo.Data[row])).ToString(fieldInfo.ExtraParam[DateTimeValue.TimeInputFormat].ToString()));
}
}
break;
}
case TimeFormatType.ReferenceTimeSec:
{
for (int row = 0; row < rowCount; ++row)
{
StringBuilder stringBuilder = rowContentList[row];
stringBuilder.Append(TxtStruct.ExportSpaceString);
if (fieldInfo.Data[row] != null)
{
stringBuilder.Append(((DateTime)(fieldInfo.Data[row]) - DateTimeValue.REFERENCE_DATE).TotalSeconds);
}
}
break;
}
default:
{
AppLog.LogErrorAndExit("错误：用_GetOneFieldTxtContent函数导出txt文件的time型的TimeFormatType非法");
break;
}
}
break;
}
case DataType.Array:
case DataType.Dict:
{
for (int row = 0; row < rowCount; ++row)
{
StringBuilder stringBuilder = rowContentList[row];
stringBuilder.Append(TxtStruct.ExportSpaceString);
if ((bool)fieldInfo.Data[row] == false)
{
stringBuilder.Append("-1");
}
}
break;
}
default:
{
AppLog.LogErrorAndExit(string.Format("_GetOneFieldTxtContent函数中未定义{0}类型数据导出至txt文件的形式", fieldInfo.DataType));
break;
}
}
}
public static void ExportToMySQL()
{
if (MySQLStruct.IsExport == false)
{
return;
}
string errorString = null;
AppLog.Log("\n导出表格数据到MySQL数据库\n");
errorString = null;
List <string> errorInfo = new List <string>();
foreach (KeyValuePair <string, TableInfo> kvp in AppValues.TableInfo)
{
string tableExportNameforMySQL = kvp.Key;
TableInfo tableInfo = kvp.Value;
foreach (FieldInfo fieldInfo in tableInfo.GetAllFieldInfo())
{
string databaseInfoString = null;
if (string.IsNullOrEmpty(databaseInfoString))
{
fieldInfo.DatabaseFieldName = null;
fieldInfo.DatabaseFieldType = null;
}
else
{
int leftBracketIndex = databaseInfoString.IndexOf('(');
int rightBracketIndex = databaseInfoString.LastIndexOf(')');
if (leftBracketIndex == -1 || rightBracketIndex == -1 || leftBracketIndex > rightBracketIndex)
{
errorString = string.Format("表名为：{0}，的第 {1} 列（第 {2} 行声明字段名为 {3} 错误，\n导出到MySQL中表字段信息声明错误，必须在字段名后的括号中声明对应数据库中的数据类型）", tableInfo.ExcelName, ExcelMethods.GetExcelColumnName(fieldInfo.ColumnSeq + 1), ExcelTableSetting.DataFieldExportDataBaseFieldInFoRowIndex, fieldInfo.DatabaseInfoString);
errorInfo.Add(errorString);
}
fieldInfo.DatabaseFieldName = databaseInfoString.Substring(0, leftBracketIndex);
fieldInfo.DatabaseFieldType = databaseInfoString.Substring(leftBracketIndex + 1, rightBracketIndex - leftBracketIndex - 1);
}
}
}
if (errorInfo.Count > 0)
{
AppLog.LogErrorAndExit(errorInfo.ToString());
}
TableExportToMySQLHelper.ConnectToDatabase(out errorString);
if (!string.IsNullOrEmpty(errorString))
{
AppLog.LogErrorAndExit(string.Format("无法连接至MySQL数据库：{0}\n导出至MySQL数据库被迫中止，请修正错误后重试\n", errorString));
}
foreach (KeyValuePair <string, TableInfo> kvp in AppValues.TableInfo)
{
string tableExportNameforMySQL = kvp.Key;
TableInfo tableInfo = kvp.Value;
List <string> inputParams = new List <string>();
if (TableAnalyzeHelper.GetOneConfigData(tableInfo, MySQLStruct.CONFIG_NAME_EXPORT_DATABASE_TABLE_NAME, ref inputParams))
{
tableExportNameforMySQL = inputParams[0];
}
if (TableAnalyzeHelper.GetOneConfigData(tableInfo, MySQLStruct.Excel_Config_ExportMySQL, ref MySQLStruct.IsExportMySQL))
{
if (MySQLStruct.IsExportMySQL == true)
{
TableExportToMySQLHelper.ExportTableToDatabase(kvp.Value, tableExportNameforMySQL, out errorString);
if (!string.IsNullOrEmpty(errorString))
{
AppLog.LogErrorAndExit(string.Format("导出失败：{0}\n导出至MySQL数据库被迫中止，请修正错误后重试\n", errorString));
}
}
}
else
{
//if (MySQLStruct.IsExport == true)
//{
TableExportToMySQLHelper.ExportTableToDatabase(kvp.Value, tableExportNameforMySQL, out errorString);
if (!string.IsNullOrEmpty(errorString))
{
AppLog.LogErrorAndExit(string.Format("导出失败：{0}\n导出至MySQL数据库被迫中止，请修正错误后重试\n", errorString));
}
//}
}
}
}
private static string _GetDateValue(FieldInfo fieldInfo, int row)
{
StringBuilder content = new StringBuilder();
DateFormatType dateFormatType = TableAnalyzeHelper.GetDateFormatType(fieldInfo.ExtraParam[LuaStruct.DateToExportFormatKey].ToString());
string exportFormatString = null;
// 若date型声明toLua的格式为dateTable，则按input格式进行导出
if (dateFormatType == DateFormatType.DataTable)
{
dateFormatType = TableAnalyzeHelper.GetDateFormatType(fieldInfo.ExtraParam[DateTimeValue.DateInputFormat].ToString());
exportFormatString = fieldInfo.ExtraParam[DateTimeValue.DateInputFormat].ToString();
}
else
{
exportFormatString = fieldInfo.ExtraParam[LuaStruct.DateToExportFormatKey].ToString();
}
switch (dateFormatType)
{
case DateFormatType.FormatString:
{
if (fieldInfo.Data[row] == null)
{
content.Append("null");
}
else
{
content.Append("\"").Append(((DateTime)(fieldInfo.Data[row])).ToString(exportFormatString)).Append("\"");
}
break;
}
case DateFormatType.ReferenceDateSec:
{
if (fieldInfo.Data[row] == null)
{
content.Append("null");
}
else
{
content.Append(((DateTime)(fieldInfo.Data[row]) - DateTimeValue.REFERENCE_DATE_LOCAL).TotalSeconds);
}
break;
}
case DateFormatType.ReferenceDateMsec:
{
if (fieldInfo.Data[row] == null)
{
content.Append("null");
}
else
{
content.Append(((DateTime)(fieldInfo.Data[row]) - DateTimeValue.REFERENCE_DATE_LOCAL).TotalMilliseconds);
}
break;
}
default:
{
AppLog.LogErrorAndExit("错误：用_GetDateValue函数导出json文件的date型的DateFormatType非法");
break;
}
}
return(content.ToString());
}
/// <summary>
/// 传入参数中，第1个必须为Excel表格所在目录，第2个必须为存放导出lua文件的目录，第3个参数为项目Client目录的路径（无需文件存在型检查规则则填-noClient），第4个参数为必须为lang文件路径（没有填-noLang）
/// 可附加参数为：-columnInfo（在生成lua文件的最上方用注释形式显示列信息，默认不开启），-unchecked（不对表格进行查错，不推荐使用），-printEmptyStringWhenLangNotMatching（当lang型数据key在lang文件中找不到对应值时，在lua文件输出字段值为空字符串即xx = ""，默认为输出nil）
/// </summary>
static void Main(string[] args)
{
// 检查第1个参数（Excel表格所在目录）是否正确
if (args.Length < 1)
{
Utils.LogErrorAndExit("错误：未输入Excel表格所在目录");
}
if (!Directory.Exists(args[0]))
{
Utils.LogErrorAndExit(string.Format("错误：输入的Excel表格所在目录不存在，路径为{0}", args[0]));
}
AppValues.ExcelFolderPath = Path.GetFullPath(args[0]);
Utils.Log(string.Format("选择的Excel所在路径：{0}", AppValues.ExcelFolderPath));
// 检查第2个参数（存放导出lua文件的目录）是否正确
if (args.Length < 2)
{
Utils.LogErrorAndExit("错误：未输入要将生成lua文件存放的路径");
}
if (!Directory.Exists(args[1]))
{
Utils.LogErrorAndExit(string.Format("错误：输入的lua文件导出路径不存在，路径为{0}", args[1]));
}
AppValues.ExportLuaFilePath = Path.GetFullPath(args[1]);
Utils.Log(string.Format("选择的lua文件导出路径：{0}", AppValues.ExportLuaFilePath));
// 检查第3个参数（项目Client目录的路径）是否正确
if (args.Length < 3)
{
Utils.LogErrorAndExit("错误：未输入项目Client目录的路径，如果不需要请输入参数-noClient");
}
if (AppValues.NO_CLIENT_PATH_STRING.Equals(args[2], StringComparison.CurrentCultureIgnoreCase))
{
Utils.LogWarning("警告：你选择了不指定Client文件夹路径，则本工具无法检查表格中填写的图片路径等对应的文件是否存在");
AppValues.ClientPath = null;
}
else if (Directory.Exists(args[2]))
{
AppValues.ClientPath = Path.GetFullPath(args[2]);
Utils.Log(string.Format("Client目录完整路径：{0}", AppValues.ClientPath));
}
else
{
Utils.LogErrorAndExit(string.Format("错误：请检查输入的Client路径是否正确{0}", args[2]));
}
// 检查第4个参数（lang文件路径）是否正确
if (args.Length < 4)
{
Utils.LogErrorAndExit("错误：未输入lang文件路径或未声明不含lang文件（使用-noLang）");
}
if (AppValues.NO_LONG_PARAM_STRING.Equals(args[3], StringComparison.CurrentCultureIgnoreCase))
{
AppValues.LangFilePath = null;
Utils.Log("选择的lang文件路径：无");
}
else if (File.Exists(args[3]))
{
AppValues.LangFilePath = Path.GetFullPath(args[3]);
Utils.Log(string.Format("选择的lang文件路径：{0}", AppValues.LangFilePath));
// 解析lang文件
string errorString = null;
AppValues.LangData = TxtConfigReader.ParseTxtConfigFile(AppValues.LangFilePath, ":", out errorString);
if (!string.IsNullOrEmpty(errorString))
{
Utils.LogErrorAndExit(errorString);
}
}
else
{
Utils.LogErrorAndExit(string.Format("错误：输入的lang文件不存在，路径为{0}", args[3]));
}
// 检查其他参数
for (int i = 4; i < args.Length; ++i)
{
string param = args[i];
switch (param)
{
case AppValues.UNCHECKED_PARAM_STRING:
{
AppValues.IsNeedCheck = false;
Utils.LogWarning("警告：你选择了不进行表格检查，请务必自己保证表格的正确性");
break;
}
case AppValues.NEED_COLUMN_INFO_PARAM_STRING:
{
AppValues.IsNeedColumnInfo = true;
Utils.LogWarning("你选择了在生成的lua文件最上方用注释形式显示列信息");
break;
}
case AppValues.LANG_NOT_MATCHING_PRINT_PARAM_STRING:
{
AppValues.IsPrintEmptyStringWhenLangNotMatching = true;
Utils.LogWarning("你选择了当lang型数据key在lang文件中找不到对应值时，在lua文件输出字段值为空字符串");
break;
}
default:
{
Utils.LogErrorAndExit(string.Format("错误：未知的指令参数{0}", param));
break;
}
}
}
// 解析本工具所在目录下的config文件
if (File.Exists(AppValues.CONFIG_FILE_NAME))
{
string errorString = null;
AppValues.ConfigData = TxtConfigReader.ParseTxtConfigFile(AppValues.CONFIG_FILE_NAME, ":", out errorString);
if (!string.IsNullOrEmpty(errorString))
{
Utils.LogErrorAndExit(errorString);
}
}
else
{
Utils.LogWarning(string.Format("警告：找不到本工具所在路径下的{0}配置文件，请确定是否真的不需要自定义配置", AppValues.CONFIG_FILE_NAME));
}
// 读取给定的Excel所在目录下的所有Excel文件，然后解析成本工具所需的数据结构
foreach (var filePath in Directory.GetFiles(AppValues.ExcelFolderPath, "*.xlsx"))
{
string errorString = null;
DataSet ds = XlsxReader.ReadXlsxFile(filePath, out errorString);
if (string.IsNullOrEmpty(errorString))
{
string fileName = Path.GetFileNameWithoutExtension(filePath);
TableInfo tableInfo = TableAnalyzeHelper.AnalyzeTable(ds.Tables[AppValues.EXCEL_SHEET_NAME], fileName, out errorString);
if (errorString != null)
{
Utils.LogErrorAndExit(string.Format("错误：解析{0}失败\n{1}", filePath, errorString));
}
else
{
// 如果有表格配置进行解析
if (ds.Tables[AppValues.EXCEL_CONFIG_NAME] != null)
{
tableInfo.TableConfig = TableAnalyzeHelper.GetTableConfig(ds.Tables[AppValues.EXCEL_CONFIG_NAME], out errorString);
if (!string.IsNullOrEmpty(errorString))
{
Utils.LogErrorAndExit(string.Format("错误：解析表格{0}的配置失败\n{1}", fileName, errorString));
}
}
AppValues.TableInfo.Add(tableInfo.TableName, tableInfo);
}
}
else
{
Utils.LogErrorAndExit(string.Format("错误：读取{0}失败\n{1}", filePath, errorString));
}
}
// 进行表格检查
bool isTableAllRight = true;
if (AppValues.IsNeedCheck == true)
{
Utils.Log("\n下面开始进行表格检查：");
foreach (TableInfo tableInfo in AppValues.TableInfo.Values)
{
string errorString = null;
Utils.Log(string.Format("检查表格\"{0}\"：", tableInfo.TableName));
TableCheckHelper.CheckTable(tableInfo, out errorString);
if (errorString != null)
{
Utils.LogError(errorString);
isTableAllRight = false;
}
else
{
Utils.Log("正确");
}
}
}
if (isTableAllRight == true)
{
Utils.Log("\n表格检查完毕，没有发现错误，开始导出为lua文件\n");
// 进行表格导出
foreach (TableInfo tableInfo in AppValues.TableInfo.Values)
{
string errorString = null;
Utils.Log(string.Format("导出表格\"{0}\"：", tableInfo.TableName));
bool isNeedExportOriginalTable = true;
// 判断是否设置了特殊导出规则
if (tableInfo.TableConfig != null && tableInfo.TableConfig.ContainsKey(AppValues.CONFIG_NAME_EXPORT))
{
List <string> inputParams = tableInfo.TableConfig[AppValues.CONFIG_NAME_EXPORT];
if (inputParams.Contains(AppValues.CONFIG_PARAM_NOT_EXPORT_ORIGINAL_TABLE))
{
isNeedExportOriginalTable = false;
if (inputParams.Count == 1)
{
Utils.LogWarning(string.Format("警告：你设置了不对表格\"{0}\"按默认方式进行导出，而又没有指定任何其他自定义导出规则，本工具对此表格不进行任何导出，请确认是否真要如此", tableInfo.TableName));
}
else
{
Utils.Log("你设置了不对此表进行默认规则导出");
}
}
// 执行设置的特殊导出规则
foreach (string param in inputParams)
{
if (!AppValues.CONFIG_PARAM_NOT_EXPORT_ORIGINAL_TABLE.Equals(param, StringComparison.CurrentCultureIgnoreCase))
{
Utils.Log(string.Format("对此表格按\"{0}\"自定义规则进行导出：", param));
TableExportToLuaHelper.SpecialExportTableToLua(tableInfo, param, out errorString);
if (errorString != null)
{
Utils.LogErrorAndExit("导出失败：" + errorString);
}
else
{
Utils.Log("成功");
}
}
}
}
// 对表格按默认方式导出（除非通过参数设置不执行此操作）
if (isNeedExportOriginalTable == true)
{
TableExportToLuaHelper.ExportTableToLua(tableInfo, out errorString);
if (errorString != null)
{
Utils.LogErrorAndExit(errorString);
}
else
{
Utils.Log("按默认方式导出成功");
}
}
}
Utils.Log("\n导出lua文件完毕\n");
}
else
{
Utils.LogError("\n表格检查完毕，但存在上面所列错误，必须全部修正后才可以进行表格导出\n");
// 将错误信息全部输出保存到txt文件中
Utils.SaveErrorInfoToFile();
}
Utils.Log("\n按任意键退出本工具");
Console.ReadKey();
}
/// <summary>
/// 传入参数中，第1个必须为Excel表格所在目录，第2个必须为存放导出lua文件的目录，第3个参数为项目Client目录的路径（无需文件存在型检查规则则填-noClient），第4个参数为必须为lang文件路径（没有填-noLang）
/// 可附加参数有：
/// 1) -columnInfo（在生成lua文件的最上方用注释形式显示列信息，默认不开启）
/// 2) -unchecked（不对表格进行查错，不推荐使用）
/// 3) -printEmptyStringWhenLangNotMatching（当lang型数据key在lang文件中找不到对应值时，在lua文件输出字段值为空字符串即xx = ""，默认为输出nil）
/// 4) -exportMySQL（将表格数据导出到MySQL数据库中，默认不导出）
/// 5) -part（后面在英文小括号内声明本次要导出的Excel文件名，用|分隔，未声明的文件将被本工具忽略）
/// 6) -allowedNullNumber（允许int、long、float型字段下填写空值，默认不允许）
/// 7) 声明要将指定的Excel表导出为csv文件需要以下2个参数：
/// -exportCsv（后面在英文小括号内声明本次要额外导出csv文件的Excel文件名，用|分隔。注意如果-part参数中未指定本次要导出某个Excel表，即便声明要导出csv文件也不会生效）
/// -exportCsvParam（可声明导出csv文件的参数）
/// 8) 声明要将指定的Excel表导出为json文件需要以下2个参数：
/// -exportJson（后面在英文小括号内声明本次要额外导出json文件的Excel文件名，用|分隔。注意如果-part参数中未指定本次要导出某个Excel表，即便声明要导出json文件也不会生效）
/// -exportJsonParam（可声明导出json文件的参数）
/// </summary>
static void Main(string[] args)
{
// 检查第1个参数（Excel表格所在目录）是否正确
if (args.Length < 1)
{
Utils.LogErrorAndExit("错误：未输入Excel表格所在目录");
}
if (!Directory.Exists(args[0]))
{
Utils.LogErrorAndExit(string.Format("错误：输入的Excel表格所在目录不存在，路径为{0}", args[0]));
}
AppValues.ExcelFolderPath = Path.GetFullPath(args[0]);
Utils.Log(string.Format("选择的Excel所在路径：{0}", AppValues.ExcelFolderPath));
// 记录目录中存在的所有Excel文件名（注意不能直接用File.Exists判断某个字符串代表的文件名是否存在，因为Windows会忽略声明的Excel文件名与实际文件名的大小写差异）
List <string> existExcelFilePaths = new List <string>(Directory.GetFiles(AppValues.ExcelFolderPath, "*.xlsx"));
List <string> existExcelFileNames = new List <string>();
foreach (string filePath in existExcelFilePaths)
{
existExcelFileNames.Add(Path.GetFileNameWithoutExtension(filePath));
}
// 检查第2个参数（存放导出lua文件的目录）是否正确
if (args.Length < 2)
{
Utils.LogErrorAndExit("错误：未输入要将生成lua文件存放的路径");
}
if (!Directory.Exists(args[1]))
{
Utils.LogErrorAndExit(string.Format("错误：输入的lua文件导出路径不存在，路径为{0}", args[1]));
}
AppValues.ExportLuaFilePath = Path.GetFullPath(args[1]);
Utils.Log(string.Format("选择的lua文件导出路径：{0}", AppValues.ExportLuaFilePath));
// 检查第3个参数（项目Client目录的路径）是否正确
if (args.Length < 3)
{
Utils.LogErrorAndExit("错误：未输入项目Client目录的路径，如果不需要请输入参数-noClient");
}
if (AppValues.NO_CLIENT_PATH_STRING.Equals(args[2], StringComparison.CurrentCultureIgnoreCase))
{
Utils.LogWarning("警告：你选择了不指定Client文件夹路径，则本工具无法检查表格中填写的图片路径等对应的文件是否存在");
AppValues.ClientPath = null;
}
else if (Directory.Exists(args[2]))
{
AppValues.ClientPath = Path.GetFullPath(args[2]);
Utils.Log(string.Format("Client目录完整路径：{0}", AppValues.ClientPath));
}
else
{
Utils.LogErrorAndExit(string.Format("错误：请检查输入的Client路径是否正确{0}", args[2]));
}
// 检查第4个参数（lang文件路径）是否正确
if (args.Length < 4)
{
Utils.LogErrorAndExit("错误：未输入lang文件路径或未声明不含lang文件（使用-noLang）");
}
if (AppValues.NO_LANG_PARAM_STRING.Equals(args[3], StringComparison.CurrentCultureIgnoreCase))
{
AppValues.LangFilePath = null;
Utils.Log("选择的lang文件路径：无");
}
else if (File.Exists(args[3]))
{
AppValues.LangFilePath = Path.GetFullPath(args[3]);
Utils.Log(string.Format("选择的lang文件路径：{0}", AppValues.LangFilePath));
// 解析lang文件
string errorString = null;
AppValues.LangData = TxtConfigReader.ParseTxtConfigFile(AppValues.LangFilePath, ":", out errorString);
if (!string.IsNullOrEmpty(errorString))
{
Utils.LogErrorAndExit(errorString);
}
}
else
{
Utils.LogErrorAndExit(string.Format("错误：输入的lang文件不存在，路径为{0}", args[3]));
}
// 检查其他参数
for (int i = 4; i < args.Length; ++i)
{
string param = args[i];
if (param.Equals(AppValues.UNCHECKED_PARAM_STRING, StringComparison.CurrentCultureIgnoreCase))
{
AppValues.IsNeedCheck = false;
Utils.LogWarning("警告：你选择了不进行表格检查，请务必自己保证表格的正确性");
}
else if (param.Equals(AppValues.NEED_COLUMN_INFO_PARAM_STRING, StringComparison.CurrentCultureIgnoreCase))
{
AppValues.IsNeedColumnInfo = true;
Utils.LogWarning("你选择了在生成的lua文件最上方用注释形式显示列信息");
}
else if (param.Equals(AppValues.LANG_NOT_MATCHING_PRINT_PARAM_STRING, StringComparison.CurrentCultureIgnoreCase))
{
AppValues.IsPrintEmptyStringWhenLangNotMatching = true;
Utils.LogWarning("你选择了当lang型数据key在lang文件中找不到对应值时，在lua文件输出字段值为空字符串");
}
else if (param.Equals(AppValues.EXPORT_MYSQL_PARAM_STRING, StringComparison.CurrentCultureIgnoreCase))
{
AppValues.IsExportMySQL = true;
Utils.LogWarning("你选择了导出表格数据到MySQL数据库");
}
else if (param.StartsWith(AppValues.PART_EXPORT_PARAM_STRING, StringComparison.CurrentCultureIgnoreCase))
{
// 解析声明的本次要导出的Excel名
string errorString = null;
string[] fileNames = Utils.GetExcelFileNames(param, out errorString);
if (errorString != null)
{
Utils.LogErrorAndExit(string.Format("错误：声明导出部分Excel表格的参数{0}后{1}", AppValues.PART_EXPORT_PARAM_STRING, errorString));
}
else
{
foreach (string fileName in fileNames)
{
AppValues.exportTableNames.Add(fileName.Trim());
}
// 检查指定导出的Excel文件是否存在
foreach (string exportExcelFileName in AppValues.exportTableNames)
{
if (!existExcelFileNames.Contains(exportExcelFileName))
{
Utils.LogErrorAndExit(string.Format("要求导出的Excel文件（{0}）不存在，请检查后重试并注意区分大小写", Utils.CombinePath(AppValues.ExcelFolderPath, string.Concat(exportExcelFileName, ".xlsx"))));
}
}
Utils.LogWarning(string.Format("警告：本次将仅检查并导出以下Excel文件：\n{0}\n", Utils.CombineString(AppValues.exportTableNames, ", ")));
}
}
// 注意：-exportCsv与-exportCsvParam均以-exportCsv开头，故要先判断-exportCsvParam分支。这里将-exportCsvParam的解析放到-exportCsv的解析之中是为了只有声明了进行csv文件导出时才解析导出参数
else if (param.StartsWith(AppValues.EXPORT_CSV_PARAM_PARAM_STRING, StringComparison.CurrentCultureIgnoreCase))
{
continue;
}
else if (param.StartsWith(AppValues.EXPORT_CSV_PARAM_STRING, StringComparison.CurrentCultureIgnoreCase))
{
// 首先解析并判断配置的csv文件导出参数是否正确
string exportCsvParamString = null;
for (int j = 4; j < args.Length; ++j)
{
string tempParam = args[j];
if (tempParam.StartsWith(AppValues.EXPORT_CSV_PARAM_PARAM_STRING, StringComparison.CurrentCultureIgnoreCase))
{
exportCsvParamString = tempParam;
break;
}
}
if (exportCsvParamString != null)
{
int leftBracketIndex = exportCsvParamString.IndexOf('(');
int rightBracketIndex = exportCsvParamString.LastIndexOf(')');
if (leftBracketIndex == -1 || rightBracketIndex == -1 || leftBracketIndex > rightBracketIndex)
{
Utils.LogErrorAndExit(string.Format("错误：声明导出csv文件的参数{0}后必须在英文小括号内声明各个具体参数", AppValues.EXPORT_CSV_PARAM_PARAM_STRING));
}
else
{
string paramString = exportCsvParamString.Substring(leftBracketIndex + 1, rightBracketIndex - leftBracketIndex - 1);
// 通过|分隔各个参数，但因为用户设置的csv文件中的字段分隔符本身可能为|，本工具采用\|配置进行转义，故需要自行从头遍历查找真正的参数分隔符
// 记录参数分隔符的下标位置
List <int> splitParamCharIndex = new List <int>();
for (int index = 0; index < paramString.Length; ++index)
{
char c = paramString[index];
if (c == '|' && (index < 1 || (index > 1 && paramString[index - 1] != '\\')))
{
splitParamCharIndex.Add(index);
}
}
// 通过识别的参数分隔符，分隔各个参数
List <string> paramStringList = new List <string>();
int lastSplitParamChatIndex = -1;
foreach (int index in splitParamCharIndex)
{
paramStringList.Add(paramString.Substring(lastSplitParamChatIndex + 1, index - lastSplitParamChatIndex - 1));
lastSplitParamChatIndex = index;
}
// 解析各个具体参数
foreach (string oneParamString in paramStringList)
{
if (string.IsNullOrEmpty(oneParamString))
{
continue;
}
string[] keyAndValue = oneParamString.Split(new char[] { '=' });
if (keyAndValue.Length != 2)
{
Utils.LogErrorAndExit(string.Format("声明的{0}参数下属的参数字符串{1}错误，参数名和配置值之间应用=分隔", AppValues.EXPORT_CSV_PARAM_PARAM_STRING, oneParamString));
}
else
{
string key = keyAndValue[0].Trim();
string value = keyAndValue[1];
if (AppValues.EXPORT_CSV_PARAM_EXPORT_PATH_PARAM_STRING.Equals(key, StringComparison.CurrentCultureIgnoreCase))
{
// 检查导出路径是否存在
if (!Directory.Exists(value))
{
Utils.LogErrorAndExit(string.Format("错误：声明的{0}参数下属的参数{1}所配置的csv文件导出路径不存在", AppValues.EXPORT_CSV_PARAM_PARAM_STRING, AppValues.EXPORT_CSV_PARAM_EXPORT_PATH_PARAM_STRING));
}
else
{
AppValues.exportCsvPath = value;
}
}
else if (AppValues.EXPORT_CSV_PARAM_EXTENSION_PARAM_STRING.Equals(key, StringComparison.CurrentCultureIgnoreCase))
{
value = value.Trim();
if (string.IsNullOrEmpty(value))
{
Utils.LogErrorAndExit(string.Format("错误：声明的{0}参数下属的参数{1}所配置的导出csv文件的扩展名不允许为空", AppValues.EXPORT_CSV_PARAM_PARAM_STRING, AppValues.EXPORT_CSV_PARAM_EXTENSION_PARAM_STRING));
}
if (value.StartsWith("."))
{
value = value.Substring(1);
}
AppValues.exportCsvExtension = value;
}
else if (AppValues.EXPORT_CSV_PARAM_SPLIT_STRING_PARAM_STRING.Equals(key, StringComparison.CurrentCultureIgnoreCase))
{
value = value.Replace("\\|", "|");
AppValues.exportCsvSplitString = value;
}
else if (AppValues.EXPORT_CSV_PARAM_IS_EXPORT_COLUMN_NAME_PARAM_STRING.Equals(key, StringComparison.CurrentCultureIgnoreCase))
{
value = value.Trim();
if ("true".Equals(value, StringComparison.CurrentCultureIgnoreCase))
{
AppValues.exportCsvIsExportColumnName = true;
}
else if ("false".Equals(value, StringComparison.CurrentCultureIgnoreCase))
{
AppValues.exportCsvIsExportColumnName = false;
}
else
{
Utils.LogErrorAndExit(string.Format("错误：声明的{0}参数下属的参数{1}所配置的值错误，必须为true或false", AppValues.EXPORT_CSV_PARAM_PARAM_STRING, AppValues.EXPORT_CSV_PARAM_IS_EXPORT_COLUMN_NAME_PARAM_STRING));
}
}
else if (AppValues.EXPORT_CSV_PARAM_IS_EXPORT_COLUMN_DATA_TYPE_PARAM_STRING.Equals(key, StringComparison.CurrentCultureIgnoreCase))
{
value = value.Trim();
if ("true".Equals(value, StringComparison.CurrentCultureIgnoreCase))
{
AppValues.exportCsvIsExportColumnDataType = true;
}
else if ("false".Equals(value, StringComparison.CurrentCultureIgnoreCase))
{
AppValues.exportCsvIsExportColumnDataType = false;
}
else
{
Utils.LogErrorAndExit(string.Format("错误：声明的{0}参数下属的参数{1}所配置的值错误，必须为true或false", AppValues.EXPORT_CSV_PARAM_PARAM_STRING, AppValues.EXPORT_CSV_PARAM_IS_EXPORT_COLUMN_DATA_TYPE_PARAM_STRING));
}
}
else
{
Utils.LogErrorAndExit(string.Format("错误：声明的{0}参数下属的参数{1}非法", AppValues.EXPORT_CSV_PARAM_PARAM_STRING, key));
}
}
}
// 要求必须含有exportPath参数
if (AppValues.exportCsvPath == null)
{
Utils.LogErrorAndExit(string.Format("错误：声明要额外导出指定Excel文件为csv文件，就必须同时在{0}参数下声明用于配置csv文件导出路径的参数{1}", AppValues.EXPORT_CSV_PARAM_PARAM_STRING, AppValues.EXPORT_CSV_PARAM_EXPORT_PATH_PARAM_STRING));
}
}
}
else
{
Utils.LogErrorAndExit(string.Format("错误：声明要额外导出指定Excel文件为csv文件，就必须同时声明用于配置csv文件导出参数的{0}", AppValues.EXPORT_CSV_PARAM_PARAM_STRING));
}
// 解析配置的要额外导出csv文件的Excel文件名
string errorString = null;
string[] fileNames = Utils.GetExcelFileNames(param, out errorString);
if (errorString != null)
{
Utils.LogErrorAndExit(string.Format("错误：声明额外导出为csv文件的参数{0}后{1}", AppValues.EXPORT_CSV_PARAM_STRING, errorString));
}
else
{
// 检查指定导出的Excel文件是否存在
foreach (string fileName in fileNames)
{
if (!existExcelFileNames.Contains(fileName))
{
Utils.LogErrorAndExit(string.Format("要求额外导出为csv文件的Excel表（{0}）不存在，请检查后重试并注意区分大小写", Utils.CombinePath(AppValues.exportCsvPath, string.Concat(fileName, ".xlsx"))));
}
else
{
AppValues.exportCsvTableNames.Add(fileName);
}
}
}
}
// 注意：-exportJson与-exportJsonParam均以-exportJson开头，故要先判断-exportJsonParam分支。这里将-exportJsonParam的解析放到-exportJson的解析之中是为了只有声明了进行json文件导出时才解析导出参数
else if (param.StartsWith(AppValues.EXPORT_JSON_PARAM_PARAM_STRING, StringComparison.CurrentCultureIgnoreCase))
{
continue;
}
else if (param.StartsWith(AppValues.EXPORT_JSON_PARAM_STRING, StringComparison.CurrentCultureIgnoreCase))
{
// 首先解析并判断配置的json文件导出参数是否正确
string exportJsonParamString = null;
for (int j = 4; j < args.Length; ++j)
{
string tempParam = args[j];
if (tempParam.StartsWith(AppValues.EXPORT_JSON_PARAM_PARAM_STRING, StringComparison.CurrentCultureIgnoreCase))
{
exportJsonParamString = tempParam;
break;
}
}
if (exportJsonParamString != null)
{
int leftBracketIndex = exportJsonParamString.IndexOf('(');
int rightBracketIndex = exportJsonParamString.LastIndexOf(')');
if (leftBracketIndex == -1 || rightBracketIndex == -1 || leftBracketIndex > rightBracketIndex)
{
Utils.LogErrorAndExit(string.Format("错误：声明导出json文件的参数{0}后必须在英文小括号内声明各个具体参数", AppValues.EXPORT_JSON_PARAM_PARAM_STRING));
}
else
{
string paramString = exportJsonParamString.Substring(leftBracketIndex + 1, rightBracketIndex - leftBracketIndex - 1);
// 通过|分隔各个参数
string[] paramStringList = paramString.Split(new char[] { '|' }, StringSplitOptions.RemoveEmptyEntries);
// 解析各个具体参数
foreach (string oneParamString in paramStringList)
{
string[] keyAndValue = oneParamString.Split(new char[] { '=' });
if (keyAndValue.Length != 2)
{
Utils.LogErrorAndExit(string.Format("声明的{0}参数下属的参数字符串{1}错误，参数名和配置值之间应用=分隔", AppValues.EXPORT_JSON_PARAM_PARAM_STRING, oneParamString));
}
else
{
string key = keyAndValue[0].Trim();
string value = keyAndValue[1];
if (AppValues.EXPORT_JSON_PARAM_EXPORT_PATH_PARAM_STRING.Equals(key, StringComparison.CurrentCultureIgnoreCase))
{
// 检查导出路径是否存在
if (!Directory.Exists(value))
{
Utils.LogErrorAndExit(string.Format("错误：声明的{0}参数下属的参数{1}所配置的json文件导出路径不存在", AppValues.EXPORT_JSON_PARAM_PARAM_STRING, AppValues.EXPORT_JSON_PARAM_EXPORT_PATH_PARAM_STRING));
}
else
{
AppValues.exportJsonPath = value;
}
}
else if (AppValues.EXPORT_JSON_PARAM_EXTENSION_PARAM_STRING.Equals(key, StringComparison.CurrentCultureIgnoreCase))
{
value = value.Trim();
if (string.IsNullOrEmpty(value))
{
Utils.LogErrorAndExit(string.Format("错误：声明的{0}参数下属的参数{1}所配置的导出json文件的扩展名不允许为空", AppValues.EXPORT_JSON_PARAM_PARAM_STRING, AppValues.EXPORT_JSON_PARAM_EXTENSION_PARAM_STRING));
}
if (value.StartsWith("."))
{
value = value.Substring(1);
}
AppValues.exportJsonExtension = value;
}
else if (AppValues.EXPORT_JSON_PARAM_IS_FORMAT_PARAM_STRING.Equals(key, StringComparison.CurrentCultureIgnoreCase))
{
value = value.Trim();
if ("true".Equals(value, StringComparison.CurrentCultureIgnoreCase))
{
AppValues.exportJsonIsFormat = true;
}
else if ("false".Equals(value, StringComparison.CurrentCultureIgnoreCase))
{
AppValues.exportJsonIsFormat = false;
}
else
{
Utils.LogErrorAndExit(string.Format("错误：声明的{0}参数下属的参数{1}所配置的值错误，必须为true或false", AppValues.EXPORT_JSON_PARAM_PARAM_STRING, AppValues.EXPORT_JSON_PARAM_IS_FORMAT_PARAM_STRING));
}
}
else
{
Utils.LogErrorAndExit(string.Format("错误：声明的{0}参数下属的参数{1}非法", AppValues.EXPORT_JSON_PARAM_PARAM_STRING, key));
}
}
}
// 要求必须含有exportPath参数
if (AppValues.exportJsonPath == null)
{
Utils.LogErrorAndExit(string.Format("错误：声明要额外导出指定Excel文件为json文件，就必须同时在{0}参数下声明用于配置json文件导出路径的参数{1}", AppValues.EXPORT_JSON_PARAM_PARAM_STRING, AppValues.EXPORT_JSON_PARAM_EXPORT_PATH_PARAM_STRING));
}
}
}
else
{
Utils.LogErrorAndExit(string.Format("错误：声明要额外导出指定Excel文件为json文件，就必须同时声明用于配置json文件导出参数的{0}", AppValues.EXPORT_JSON_PARAM_PARAM_STRING));
}
// 解析配置的要额外导出json文件的Excel文件名
string errorString = null;
string[] fileNames = Utils.GetExcelFileNames(param, out errorString);
if (errorString != null)
{
Utils.LogErrorAndExit(string.Format("错误：声明额外导出为json文件的参数{0}后{1}", AppValues.EXPORT_JSON_PARAM_STRING, errorString));
}
else
{
// 检查指定导出的Excel文件是否存在
foreach (string fileName in fileNames)
{
if (!existExcelFileNames.Contains(fileName))
{
Utils.LogErrorAndExit(string.Format("要求额外导出为json文件的Excel表（{0}）不存在，请检查后重试并注意区分大小写", Utils.CombinePath(AppValues.exportJsonPath, string.Concat(fileName, ".xlsx"))));
}
else
{
AppValues.exportJsonTableNames.Add(fileName);
}
}
}
}
else if (param.StartsWith(AppValues.ALLOWED_NULL_NUMBER_PARAM_STRING, StringComparison.CurrentCultureIgnoreCase))
{
AppValues.IsAllowedNullNumber = true;
Utils.LogWarning("警告：你选择了允许int、long、float字段中存在空值，建议为逻辑上不允许为空的数值型字段声明使用notEmpty检查规则");
}
else
{
Utils.LogErrorAndExit(string.Format("错误：未知的指令参数{0}", param));
}
}
// 如果未指定导出部分Excel文件，则全部导出
if (AppValues.exportTableNames.Count == 0)
{
foreach (string filePath in Directory.GetFiles(AppValues.ExcelFolderPath, "*.xlsx"))
{
string fileName = Path.GetFileNameWithoutExtension(filePath);
if (fileName.StartsWith(AppValues.EXCEL_TEMP_FILE_FILE_NAME_START_STRING))
{
Utils.LogWarning(string.Format("目录中的{0}文件为Excel自动生成的临时文件，将被忽略处理", filePath));
}
else
{
AppValues.exportTableNames.Add(Path.GetFileNameWithoutExtension(filePath));
}
}
}
// 如果声明要额外导出为csv文件的Excel表本身在本次被忽略，需要进行警告
List <string> warnExportCsvTableNames = new List <string>();
foreach (string exportCsvTableName in AppValues.exportCsvTableNames)
{
if (!AppValues.exportTableNames.Contains(exportCsvTableName))
{
warnExportCsvTableNames.Add(exportCsvTableName);
}
}
if (warnExportCsvTableNames.Count > 0)
{
Utils.LogWarning(string.Format("警告：以下Excel表声明为要额外导出为csv文件，但在{0}参数中未声明本次要对其进行导出，本工具将不对这些表格执行导出csv文件的操作\n{1}", AppValues.PART_EXPORT_PARAM_STRING, Utils.CombineString(warnExportCsvTableNames, ", ")));
foreach (string tableName in warnExportCsvTableNames)
{
AppValues.exportCsvTableNames.Remove(tableName);
}
}
if (AppValues.exportCsvTableNames.Count > 0)
{
Utils.Log(string.Format("本次将以下Excel表额外导出为csv文件：\n{0}\n", Utils.CombineString(AppValues.exportCsvTableNames, ", ")));
}
// 如果声明要额外导出为json文件的Excel表本身在本次被忽略，需要进行警告
List <string> warnExportJsonTableNames = new List <string>();
foreach (string exportJsonTableName in AppValues.exportJsonTableNames)
{
if (!AppValues.exportTableNames.Contains(exportJsonTableName))
{
warnExportJsonTableNames.Add(exportJsonTableName);
}
}
if (warnExportJsonTableNames.Count > 0)
{
Utils.LogWarning(string.Format("警告：以下Excel表声明为要额外导出为json文件，但在{0}参数中未声明本次要对其进行导出，本工具将不对这些表格执行导出json文件的操作\n{1}", AppValues.PART_EXPORT_PARAM_STRING, Utils.CombineString(warnExportJsonTableNames, ", ")));
foreach (string tableName in warnExportJsonTableNames)
{
AppValues.exportJsonTableNames.Remove(tableName);
}
}
if (AppValues.exportJsonTableNames.Count > 0)
{
Utils.Log(string.Format("本次将以下Excel表额外导出为json文件：\n{0}\n", Utils.CombineString(AppValues.exportJsonTableNames, ", ")));
}
// 解析本工具所在目录下的config文件
string configFilePath = Utils.CombinePath(AppValues.PROGRAM_FOLDER_PATH, AppValues.CONFIG_FILE_NAME);
if (File.Exists(configFilePath))
{
string errorString = null;
AppValues.ConfigData = TxtConfigReader.ParseTxtConfigFile(configFilePath, ":", out errorString);
if (!string.IsNullOrEmpty(errorString))
{
Utils.LogErrorAndExit(errorString);
}
}
else
{
Utils.LogWarning(string.Format("警告：找不到本工具所在路径下的{0}配置文件，请确定是否真的不需要自定义配置", AppValues.CONFIG_FILE_NAME));
}
// 读取部分配置项并进行检查
const string ERROR_STRING_FORMAT = "配置项\"{0}\"所设置的值\"{1}\"非法：{2}\n";
StringBuilder errorStringBuilder = new StringBuilder();
string tempErrorString = null;
if (AppValues.ConfigData.ContainsKey(AppValues.APP_CONFIG_KEY_DEFAULT_DATE_INPUT_FORMAT))
{
AppValues.DefaultDateInputFormat = AppValues.ConfigData[AppValues.APP_CONFIG_KEY_DEFAULT_DATE_INPUT_FORMAT].Trim();
if (TableCheckHelper.CheckDateInputDefine(AppValues.DefaultDateInputFormat, out tempErrorString) == false)
{
errorStringBuilder.AppendFormat(ERROR_STRING_FORMAT, AppValues.APP_CONFIG_KEY_DEFAULT_DATE_INPUT_FORMAT, AppValues.DefaultDateInputFormat, tempErrorString);
}
}
if (AppValues.ConfigData.ContainsKey(AppValues.APP_CONFIG_KEY_DEFAULT_DATE_TO_LUA_FORMAT))
{
AppValues.DefaultDateToLuaFormat = AppValues.ConfigData[AppValues.APP_CONFIG_KEY_DEFAULT_DATE_TO_LUA_FORMAT].Trim();
if (TableCheckHelper.CheckDateToLuaDefine(AppValues.DefaultDateToLuaFormat, out tempErrorString) == false)
{
errorStringBuilder.AppendFormat(ERROR_STRING_FORMAT, AppValues.APP_CONFIG_KEY_DEFAULT_DATE_TO_LUA_FORMAT, AppValues.DefaultDateToLuaFormat, tempErrorString);
}
}
if (AppValues.ConfigData.ContainsKey(AppValues.APP_CONFIG_KEY_DEFAULT_DATE_TO_DATABASE_FORMAT))
{
AppValues.DefaultDateToDatabaseFormat = AppValues.ConfigData[AppValues.APP_CONFIG_KEY_DEFAULT_DATE_TO_DATABASE_FORMAT].Trim();
if (TableCheckHelper.CheckDateToDatabaseDefine(AppValues.DefaultDateToDatabaseFormat, out tempErrorString) == false)
{
errorStringBuilder.AppendFormat(ERROR_STRING_FORMAT, AppValues.APP_CONFIG_KEY_DEFAULT_DATE_TO_DATABASE_FORMAT, AppValues.DefaultDateToDatabaseFormat, tempErrorString);
}
}
if (AppValues.ConfigData.ContainsKey(AppValues.APP_CONFIG_KEY_DEFAULT_TIME_INPUT_FORMAT))
{
AppValues.DefaultTimeInputFormat = AppValues.ConfigData[AppValues.APP_CONFIG_KEY_DEFAULT_TIME_INPUT_FORMAT].Trim();
if (TableCheckHelper.CheckTimeDefine(AppValues.DefaultTimeInputFormat, out tempErrorString) == false)
{
errorStringBuilder.AppendFormat(ERROR_STRING_FORMAT, AppValues.APP_CONFIG_KEY_DEFAULT_TIME_INPUT_FORMAT, AppValues.DefaultTimeInputFormat, tempErrorString);
}
}
if (AppValues.ConfigData.ContainsKey(AppValues.APP_CONFIG_KEY_DEFAULT_TIME_TO_LUA_FORMAT))
{
AppValues.DefaultTimeToLuaFormat = AppValues.ConfigData[AppValues.APP_CONFIG_KEY_DEFAULT_TIME_TO_LUA_FORMAT].Trim();
if (TableCheckHelper.CheckTimeDefine(AppValues.DefaultTimeToLuaFormat, out tempErrorString) == false)
{
errorStringBuilder.AppendFormat(ERROR_STRING_FORMAT, AppValues.APP_CONFIG_KEY_DEFAULT_TIME_TO_LUA_FORMAT, AppValues.DefaultTimeToLuaFormat, tempErrorString);
}
}
if (AppValues.ConfigData.ContainsKey(AppValues.APP_CONFIG_KEY_DEFAULT_TIME_TO_DATABASE_FORMAT))
{
AppValues.DefaultTimeToDatabaseFormat = AppValues.ConfigData[AppValues.APP_CONFIG_KEY_DEFAULT_TIME_TO_DATABASE_FORMAT].Trim();
if (TableCheckHelper.CheckTimeDefine(AppValues.DefaultTimeToDatabaseFormat, out tempErrorString) == false)
{
errorStringBuilder.AppendFormat(ERROR_STRING_FORMAT, AppValues.APP_CONFIG_KEY_DEFAULT_TIME_TO_DATABASE_FORMAT, AppValues.DefaultTimeToDatabaseFormat, tempErrorString);
}
}
string errorConfigString = errorStringBuilder.ToString();
if (!string.IsNullOrEmpty(errorConfigString))
{
errorConfigString = string.Concat("配置文件中存在以下错误，请修正后重试\n", errorConfigString);
Utils.LogErrorAndExit(errorConfigString);
}
// 读取给定的Excel所在目录下的所有Excel文件，然后解析成本工具所需的数据结构
Utils.Log("开始解析Excel所在目录下的所有Excel文件：");
Stopwatch stopwatch = new Stopwatch();
foreach (string filePath in Directory.GetFiles(AppValues.ExcelFolderPath, "*.xlsx"))
{
string fileName = Path.GetFileNameWithoutExtension(filePath);
if (fileName.StartsWith(AppValues.EXCEL_TEMP_FILE_FILE_NAME_START_STRING))
{
continue;
}
Utils.Log(string.Format("解析表格\"{0}\"：", fileName), ConsoleColor.Green);
stopwatch.Reset();
stopwatch.Start();
string errorString = null;
DataSet ds = XlsxReader.ReadXlsxFile(filePath, out errorString);
stopwatch.Stop();
Utils.Log(string.Format("成功，耗时：{0}毫秒", stopwatch.ElapsedMilliseconds));
if (string.IsNullOrEmpty(errorString))
{
TableInfo tableInfo = TableAnalyzeHelper.AnalyzeTable(ds.Tables[AppValues.EXCEL_DATA_SHEET_NAME], fileName, out errorString);
if (errorString != null)
{
Utils.LogErrorAndExit(string.Format("错误：解析{0}失败\n{1}", filePath, errorString));
}
else
{
// 如果有表格配置进行解析
if (ds.Tables[AppValues.EXCEL_CONFIG_SHEET_NAME] != null)
{
tableInfo.TableConfig = TableAnalyzeHelper.GetTableConfig(ds.Tables[AppValues.EXCEL_CONFIG_SHEET_NAME], out errorString);
if (!string.IsNullOrEmpty(errorString))
{
Utils.LogErrorAndExit(string.Format("错误：解析表格{0}的配置失败\n{1}", fileName, errorString));
}
}
AppValues.TableInfo.Add(tableInfo.TableName, tableInfo);
}
}
else
{
Utils.LogErrorAndExit(string.Format("错误：读取{0}失败\n{1}", filePath, errorString));
}
}
// 进行表格检查
bool isTableAllRight = true;
if (AppValues.IsNeedCheck == true)
{
Utils.Log("\n下面开始进行表格检查：");
foreach (string tableName in AppValues.exportTableNames)
{
TableInfo tableInfo = AppValues.TableInfo[tableName];
string errorString = null;
Utils.Log(string.Format("检查表格\"{0}\"：", tableInfo.TableName), ConsoleColor.Green);
TableCheckHelper.CheckTable(tableInfo, out errorString);
if (errorString != null)
{
Utils.LogError(errorString);
isTableAllRight = false;
}
else
{
Utils.Log("正确");
}
}
}
if (isTableAllRight == true)
{
Utils.Log("\n表格检查完毕，没有发现错误，开始导出为lua文件\n");
// 进行表格导出
foreach (string tableName in AppValues.exportTableNames)
{
TableInfo tableInfo = AppValues.TableInfo[tableName];
string errorString = null;
Utils.Log(string.Format("导出表格\"{0}\"：", tableInfo.TableName), ConsoleColor.Green);
bool isNeedExportOriginalTable = true;
// 判断是否设置了特殊导出规则
if (tableInfo.TableConfig != null && tableInfo.TableConfig.ContainsKey(AppValues.CONFIG_NAME_EXPORT))
{
List <string> inputParams = tableInfo.TableConfig[AppValues.CONFIG_NAME_EXPORT];
if (inputParams.Contains(AppValues.CONFIG_PARAM_NOT_EXPORT_ORIGINAL_TABLE))
{
isNeedExportOriginalTable = false;
if (inputParams.Count == 1)
{
Utils.LogWarning(string.Format("警告：你设置了不对表格\"{0}\"按默认方式进行导出，而又没有指定任何其他自定义导出规则，本工具对此表格不进行任何导出，请确认是否真要如此", tableInfo.TableName));
}
else
{
Utils.Log("你设置了不对此表进行默认规则导出");
}
}
// 执行设置的特殊导出规则
foreach (string param in inputParams)
{
if (!AppValues.CONFIG_PARAM_NOT_EXPORT_ORIGINAL_TABLE.Equals(param, StringComparison.CurrentCultureIgnoreCase))
{
Utils.Log(string.Format("对此表格按\"{0}\"自定义规则进行导出：", param));
TableExportToLuaHelper.SpecialExportTableToLua(tableInfo, param, out errorString);
if (errorString != null)
{
Utils.LogErrorAndExit(string.Format("导出失败：\n{0}\n", errorString));
}
else
{
Utils.Log("成功");
}
}
}
}
// 对表格按默认方式导出（除非通过参数设置不执行此操作）
if (isNeedExportOriginalTable == true)
{
TableExportToLuaHelper.ExportTableToLua(tableInfo, out errorString);
if (errorString != null)
{
Utils.LogErrorAndExit(errorString);
}
else
{
Utils.Log("按默认方式导出成功");
}
}
// 判断是否要额外导出为csv文件
if (AppValues.exportCsvTableNames.Contains(tableName))
{
TableExportToCsvHelper.ExportTableToCsv(tableInfo, out errorString);
if (errorString != null)
{
Utils.LogErrorAndExit(errorString);
}
else
{
Utils.Log("额外导出为csv文件成功");
}
}
// 判断是否要额外导出为json文件
if (AppValues.exportJsonTableNames.Contains(tableName))
{
TableExportToJsonHelper.ExportTableToJson(tableInfo, out errorString);
if (errorString != null)
{
Utils.LogErrorAndExit(errorString);
}
else
{
Utils.Log("额外导出为json文件成功");
}
}
}
Utils.Log("\n导出lua文件完毕\n");
// 进行数据库导出
if (AppValues.IsExportMySQL == true)
{
Utils.Log("\n导出表格数据到MySQL数据库\n");
string errorString = null;
TableExportToMySQLHelper.ConnectToDatabase(out errorString);
if (!string.IsNullOrEmpty(errorString))
{
Utils.LogErrorAndExit(string.Format("无法连接至MySQL数据库：{0}\n导出至MySQL数据库被迫中止，请修正错误后重试\n", errorString));
}
foreach (string tableName in AppValues.exportTableNames)
{
TableInfo tableInfo = AppValues.TableInfo[tableName];
TableExportToMySQLHelper.ExportTableToDatabase(tableInfo, out errorString);
if (!string.IsNullOrEmpty(errorString))
{
Utils.LogErrorAndExit(string.Format("导出失败：{0}\n导出至MySQL数据库被迫中止，请修正错误后重试\n", errorString));
}
}
Utils.Log("\n导出到数据库完毕\n");
}
}
else
{
Utils.LogError("\n表格检查完毕，但存在上面所列错误，必须全部修正后才可以进行表格导出\n");
// 将错误信息全部输出保存到txt文件中
Utils.SaveErrorInfoToFile();
}
Utils.Log("\n按任意键退出本工具");
Console.ReadKey();
}
private static string _GetCsClassFieldDefine(FieldInfo fieldInfo)
{
StringBuilder stringBuilder = new StringBuilder();
switch (fieldInfo.DataType)
{
case DataType.Int:
case DataType.Long:
case DataType.Float:
case DataType.Bool:
case DataType.String:
{
stringBuilder.Append(fieldInfo.DataType.ToString().ToLower());
break;
}
case DataType.Lang:
{
stringBuilder.Append("string");
break;
}
case DataType.Json:
{
stringBuilder.Append("LitJson.JsonData");
break;
}
case DataType.Array:
{
stringBuilder.Append("List<");
stringBuilder.Append(_GetCsClassFieldDefine(fieldInfo.ChildField[0]));
stringBuilder.Append(">");
break;
}
case DataType.Dict:
{
// 如果dict型下属各字段都是同一种类型，则Dictionary的值类型可以具体指定，否则只能设为通用的Object
bool isSameChildDataType = true;
DataType firstDataType = fieldInfo.ChildField[0].DataType;
foreach (FieldInfo childFieldInfo in fieldInfo.ChildField)
{
if (childFieldInfo.DataType != firstDataType)
{
isSameChildDataType = false;
break;
}
}
if (isSameChildDataType == true)
{
stringBuilder.Append("Dictionary<string, ");
stringBuilder.Append(_GetCsClassFieldDefine(fieldInfo.ChildField[0]));
stringBuilder.Append(">");
}
else
{
stringBuilder.Append("Dictionary<string, object>");
}
break;
}
case DataType.Date:
{
DateFormatType dateFormatType = TableAnalyzeHelper.GetDateFormatType(fieldInfo.ExtraParam[AppValues.TABLE_INFO_EXTRA_PARAM_KEY_DATE_TO_LUA_FORMAT].ToString());
if (dateFormatType == DateFormatType.ReferenceDateSec)
{
stringBuilder.Append("int");
}
else if (dateFormatType == DateFormatType.ReferenceDateMsec)
{
stringBuilder.Append("long");
}
else
{
stringBuilder.Append("DateTime");
}
break;
}
case DataType.Time:
{
TimeFormatType timeFormatType = TableAnalyzeHelper.GetTimeFormatType(fieldInfo.ExtraParam[AppValues.TABLE_INFO_EXTRA_PARAM_KEY_TIME_TO_LUA_FORMAT].ToString());
if (timeFormatType == TimeFormatType.ReferenceTimeSec)
{
stringBuilder.Append("int");
}
else
{
stringBuilder.Append("DateTime");
}
break;
}
case DataType.TableString:
{
if (fieldInfo.TableStringFormatDefine.KeyDefine.KeyType == TableStringKeyType.Seq)
{
stringBuilder.Append("List<");
switch (fieldInfo.TableStringFormatDefine.ValueDefine.ValueType)
{
case TableStringValueType.True:
{
stringBuilder.Append("bool");
break;
}
case TableStringValueType.Table:
{
stringBuilder.Append("Dictionary<string, object>");
break;
}
case TableStringValueType.DataInIndex:
{
string valueDataTypeString = _GetCsClassTableStringDataType(fieldInfo.TableStringFormatDefine.ValueDefine.DataInIndexDefine.DataType);
if (valueDataTypeString == null)
{
Utils.LogErrorAndExit("用_GetCsClassFieldDefine函数导出csv对应C#类文件中tableString型字段的seq型key的dataInIndex型value的数据类型非法");
}
else
{
stringBuilder.Append(valueDataTypeString);
}
break;
}
default:
{
Utils.LogErrorAndExit("用_GetCsClassFieldDefine函数导出csv对应C#类文件中tableString型字段的seq型key的value类型非法");
break;
}
}
stringBuilder.Append(">");
}
else if (fieldInfo.TableStringFormatDefine.KeyDefine.KeyType == TableStringKeyType.DataInIndex)
{
stringBuilder.Append("Dictionary<");
// key
string keyDataTypeString = _GetCsClassTableStringDataType(fieldInfo.TableStringFormatDefine.KeyDefine.DataInIndexDefine.DataType);
if (keyDataTypeString == null)
{
Utils.LogErrorAndExit("用_GetCsClassFieldDefine函数导出csv对应C#类文件中tableString型字段的dataInIndex型key的数据类型非法");
}
else
{
stringBuilder.Append(keyDataTypeString);
}
stringBuilder.Append(" ,");
// value
switch (fieldInfo.TableStringFormatDefine.ValueDefine.ValueType)
{
case TableStringValueType.True:
{
stringBuilder.Append("bool");
break;
}
case TableStringValueType.Table:
{
stringBuilder.Append("Dictionary<string, object>");
break;
}
case TableStringValueType.DataInIndex:
{
string valueDataTypeString = _GetCsClassTableStringDataType(fieldInfo.TableStringFormatDefine.KeyDefine.DataInIndexDefine.DataType);
if (valueDataTypeString == null)
{
Utils.LogErrorAndExit("用_GetCsClassFieldDefine函数导出csv对应C#类文件中tableString型字段的dataInIndex型key的dataInIndex型value的数据类型非法");
}
else
{
stringBuilder.Append(valueDataTypeString);
}
break;
}
default:
{
Utils.LogErrorAndExit("用_GetCsClassFieldDefine函数导出csv对应C#类文件中tableString型字段的dataInIndex型key的value类型非法");
break;
}
}
stringBuilder.Append(">");
}
else
{
Utils.LogErrorAndExit("用_GetCsClassFieldDefine函数导出csv对应C#类文件中tableString型字段的key非法");
}
break;
}
case DataType.MapString:
{
stringBuilder.Append("LitJson.JsonData");
break;
}
default:
{
Utils.LogErrorAndExit("用_GetCsClassFieldDefine函数导出csv对应C#类文件的字段DataType非法");
break;
}
}
return(stringBuilder.ToString());
}
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);
}
}
public static void ExportToJson(TableInfo tableInfo)
{
string errorString = null;
// 判断是否设置要是否要导出null字段
TableAnalyzeHelper.GetOneConfigData(tableInfo, JsonStruct.Excel_Config_NotExportJsonNull, ref JsonStruct.IsExportJsonNullConfig);
//if (tableInfo.TableConfig != null && tableInfo.TableConfig.ContainsKey(JsonStruct.Excel_Config_NotExportJsonNull))
//{
// if (tableInfo.TableConfig[JsonStruct.Excel_Config_NotExportJsonNull].Count > 0)
// {
// if ("false".Equals(tableInfo.TableConfig[JsonStruct.Excel_Config_NotExportJsonNull][0], StringComparison.CurrentCultureIgnoreCase))
// {
// JsonStruct.IsExportJsonNullConfig = false;
// }
// }
//}
// 以下为旧代码：判断是否设置了特殊导出规则
/*
* if (tableInfo.TableConfig != null && tableInfo.TableConfig.ContainsKey(JsonStruct.Excel_Config_SpecialExportJson))
* {
* List<string> inputParams = tableInfo.TableConfig[JsonStruct.Excel_Config_SpecialExportJson];
* if (inputParams.Contains(JsonStruct.Excel_Config_NotExportJsonOriginalTable))
* {
* JsonStruct.IsExportJson = false;
* if (inputParams.Count == 1)
* AppLog.LogWarning(string.Format("警告：你设置了不对表格\"{0}\"按默认方式进行导出json，而又没有指定任何其他自定义导出规则，本工具对此表格不进行任何导出，请确认是否真要如此", tableInfo.TableName));
* else
* AppLog.Log("你设置了不对此表进行默认规则导出json");
* }
* // 执行设置的特殊导出规则
* foreach (string param in inputParams)
* {
* if (!JsonStruct.Excel_Config_NotExportJsonOriginalTable.Equals(param, StringComparison.CurrentCultureIgnoreCase))
* {
* AppLog.Log(string.Format("对此表格按\"{0}\"自定义规则进行导出：", param));
* TableExportToJsonHelper.SpecialExportTableToJson(tableInfo, param, out errorString);
* if (errorString != null)
* AppLog.LogErrorAndExit(string.Format("导出特殊json失败：\n{0}\n", errorString));
* else
* AppLog.Log("导出特殊json成功");
* }
* }
* }
*/
//以下为新的代码
if (TableAnalyzeHelper.GetOneConfigData(tableInfo, JsonStruct.Excel_Config_SpecialExportJson, ref JsonStruct.SpecialExportJsonParams))
{
// 特殊嵌套导出
foreach (string param in JsonStruct.SpecialExportJsonParams)
{
AppLog.Log(string.Format("对此表格按\"{0}\"自定义规则进行导出json：", param));
TableExportToJsonHelper.SpecialExportTableToJson(tableInfo, param, out errorString);
if (errorString != null)
{
AppLog.LogErrorAndExit(string.Format("导出特殊json失败：\n{0}\n", errorString));
}
else
{
AppLog.Log("导出特殊json成功");
}
}
}
// 对表格按默认方式导出
if (TableAnalyzeHelper.GetOneConfigData(tableInfo, JsonStruct.Excel_Config_ExportJson, ref JsonStruct.IsExportJson))
{
// 对表格按默认方式导出
if (JsonStruct.IsExportJson == true)
{
TableExportToJsonHelper.ExportTableToJson(tableInfo, out errorString);
if (errorString != null)
{
AppLog.LogErrorAndExit(errorString);
}
else
{
AppLog.Log("按默认方式导出json成功");
}
}
}
else
{
// 对表格按默认方式导出
if (JsonStruct.IsExport == true)
{
TableExportToJsonHelper.ExportTableToJson(tableInfo, out errorString);
if (errorString != null)
{
AppLog.LogErrorAndExit(errorString);
}
else
{
AppLog.Log("按默认方式导出json成功");
}
}
}
}
public static void ExportToErlang(TableInfo tableInfo)
{
string errorString = null;
if (ErlangStruct.ExportErlangIsFormat == false)
{
ErlangStruct.IndentationString = "";
}
// 判断是否设置要是否要导出null字段
TableAnalyzeHelper.GetOneConfigData(tableInfo, ErlangStruct.Excel_Config_NotExportErlangNull, ref ErlangStruct.IsExportErlangNullConfig);
if (TableAnalyzeHelper.GetOneConfigData(tableInfo, ErlangStruct.Excel_Config_SpecialExportErlang, ref ErlangStruct.SpecialExportErlangParams))
{
// 特殊嵌套导出
foreach (string param in ErlangStruct.SpecialExportErlangParams)
{
AppLog.Log(string.Format("对此表格按\"{0}\"自定义规则进行导出erlang：", param));
TableExportToErlangHelper.SpecialExportTableToErlang(tableInfo, param, out errorString);
if (errorString != null)
{
AppLog.LogErrorAndExit(string.Format("导出特殊erlang失败：\n{0}\n", errorString));
}
else
{
AppLog.Log("导出特殊erlang成功");
}
}
}
// 对表格按默认方式导出
if (TableAnalyzeHelper.GetOneConfigData(tableInfo, ErlangStruct.Excel_Config_ExportErlang, ref ErlangStruct.IsExportErlang))
{
// 对表格按默认方式导出
if (ErlangStruct.IsExportErlang == true)
{
TableExportToErlangHelper.ExportTableToErlang(tableInfo, out errorString);
if (errorString != null)
{
AppLog.LogErrorAndExit(errorString);
}
else
{
AppLog.Log("按默认方式导出erlang成功");
}
}
}
else
{
// 对表格按默认方式导出
if (ErlangStruct.IsExport == true)
{
TableExportToErlangHelper.ExportTableToErlang(tableInfo, out errorString);
if (errorString != null)
{
AppLog.LogErrorAndExit(errorString);
}
else
{
AppLog.Log("按默认方式导出erlang成功");
}
}
}
}
//第1个参数，Excel所在路径格式：Excel
//第2个以后参数可选参数
/*
* 公共参数格式：PublicSetting(是否包含子目录=true|是否充许数字型为空=true|是否需要检查=false|ClientPath=)
* 公共参数格式：PublicSetting(IsIncludeSubfolder=true|IsAllowedNullNumber=true|IsNeedCheck=false)
* 公共参数格式：MergeTable()
* 公共参数格式：MergeTable(IsMerge=true|IsMergeSingle=false|item=item100,item101|monster=monster301,monster306)
* 多语言：MoreLanguage(IsMoreLanguage=false|NeedLanguage=_ft|OtherLanguage=_yn,_English|IsAddSaveType=false|IsGetSourceTextFile=false)
* lang参数：Lang(IsLang=true|LangPath=lang.txt|IsLangNull=false)
* config参数：Config(ConfigPat=config.txt)
* 只导出部分表格式（优先判定）：OnlyExportPartExcel(item|skill)
* 指定不导出哪些表格式（后判定）：ExceptExportExcel(item|skill)
* 导出Lua参数格式：ExportLua(是否导出Lua=true|导出路径=Save/Lua|是否按原目录结构保存=ture|是否需要生成头部信息|数组类型是否需要[1]=值格式|导出文件内容是否以文件名开头|导出时在文件名前添加前缀)
* 导出Lua参数格式：ExportLua(IsExport=true|ExportPath=Save/Lua|IsExportKeepDirectoryStructure=ture|IsNeedColumnInfo=ture|IsArrayFieldName=true|IsTableNameStart=false|IsFormat=true|ExportNameBeforeAdd=cfg_)
* 导出json参数格式：ExportJson(是否导出Lua=true|导出路径=Save/Lua|是否按原目录结构保存=true|包含在一个json array的形式=false|是否包含主键列对应的键值对=true|是否格式化=true)
* 导出json参数格式：ExportJson(IsExport=true|ExportPath=Save/Json|IsExportKeepDirectoryStructure=true|IsArrayFormat=false|IsKeyColumnValue=true|IsFormat=true|ExportNameBeforeAdd=tb_)
* 导出txt参数格式：ExportTxt(IsExport=true|ExportPath=Save/Txt|IsExportKeepDirectoryStructure=true|ExportNameBeforeAdd=tb_)
* 导出mysql参数格式：ExportMySQL(IsExport=true|Server=127.0.0.1|Port=3306|Uid=root|Password=root|Database=mydb|Charset=utf8)
* 导出sqlite参数格式：
* 导出erlang参数格式：ExportErlang(IsExport=true|ExportPath=Save/Erl|IsExportKeepDirectoryStructure=true|IsFormat=true|ExportNameBeforeAdd=tb_)
* 导出hrl参数格式：ExportHrl(IsExport=true|ExportPath=Save/hrl|IsExportKeepDirectoryStructure=true|ExportNameBeforeAdd=tb_)
* 导出luafile参数格式：ExportLuaFile(IsExport=true|ExportPath=Save/luafile|IsExportKeepDirectoryStructure=true)
*
* AppLog参数格式：AppLog(IsPrintLog=true|IsPrintLogWarning=true|IsPrintLogError=true|IsSaveLog=true|IsSaveLogWarning=true|IsSaveLogError=true)
*/
private static void Main(string[] args)
{
LoadResourceDll.RegistDLL();
try
{
//if(!StringModule.GetDotNetVersion("4.0"))
//{
// AppLog.LogWarning("警告：你可能未安装framework4.0，请下载安装：\n"+"https://microsoft-net-framework-3-0.updatestar.com", ConsoleColor.Yellow);
//}
AppLog.Log("检查传入参数...", ConsoleColor.White);
if (args.Length < 1)
{
AppLog.LogErrorAndExit("错误：未输入Excel表格所在目录,第1个参数必须为Excel所在目录");
}
if (!Directory.Exists(args[0]))
{
AppLog.LogErrorAndExit(string.Format("错误：输入的Excel表格所在目录不存在，路径为{0}", args[0]));
}
ExcelFolder.ExcelPath = Path.GetFullPath(args[0]);
//从第2个参数起，检查可选参数
for (int i = 1; i < args.Length; ++i)
{
BatParamInfo batParamInfo = new BatParamInfo(args[i], i);
AppValues.BatParamInfo.Add(batParamInfo.ParamName, batParamInfo);
}
AppLog.GetParamValue();
AppLang.ReadLangData();
AppConfig.ReadConfig();
AppLanguage.GetParamValue();
ExcelFolder.GetExportTables();
AppLanguage.GetLanguageDictData();
//解析Excel表格并替换翻译
TableAnalyzeHelper.AnalyzeAllTable(ExcelFolder.ExportTables);
//多语言下，创建多语言集合，即将简体文本提出取来待翻译
AppLanguage.CreateLanguageDictFile();
//合并表格
BatExportMergeSetting batExportMergeSetting = new BatExportMergeSetting();
AppValues.MergeTableList = batExportMergeSetting.MergeTableList;
//检查表格
AppLog.Log("开始检查表格...");
CheckTableInfo.CheckTable();
//开始导出 AppValues.TableInfo
ExportTxt.ExportToTxt();
ExportJson.ExportToJson();
ExportErlang.ExportToErlang();
ExportServerJson.ExportToJson();
ExportLua.ExportToLua();
ExportMySQL.ExportToMySQL();
AppLog.Log("\n全部文件导出成功");
#if DEBUG
Console.ReadKey();
#endif
}
catch (Exception e)
{
if (AppValues.App_Config_Error == true)
{
AppLog.LogErrorAndExit(e.ToString());
}
else
{
#if DEBUG
AppLog.LogErrorAndExit(e.ToString());
#endif
// AppLog.LogErrorAndExit("\n出现错误，请检查配置表");
}
}
}
