/// <summary>
/// 保存数据
/// </summary>
/// <param name="file">GTSharp.GTApp.GTDataFile</param>
public static GTDataFile Save(GTDataFile file)
{
// 文件循环
GTFile fileitem = file.Files[0];
// 初始化workbook实例
Workbook workbook = new Workbook();
// 加载Excel文档
workbook.LoadFromStream(new MemoryStream(fileitem.File), ExcelVersion.Version2007);
// 获取第一个工作表
Worksheet sheet = workbook.Worksheets[0];
// 数据循环
foreach (GTData dataitem in fileitem.Datas)
{
// 是否导入数据
if (dataitem.Points.Count > 0)
{
// 循环数据单元格输出
foreach (GTPoint item in dataitem.Points)
{
sheet.SetCellValue(item.X2, item.Y2, dataitem.Table.Rows[item.X1][item.Y1].ToString());
}
}
else
{
// 导出数据到Excel
sheet.DataTableToExcel(dataitem.Table, dataitem.RowIndexBegin);
}
}
file.Files[0].Workbook = workbook;
return(file);
}
public ActionResult SaveUploadFileGT(string FileName, string SaveFileName, string Id, string GTType)
{
string filetype = "Other";
string lowerFileName = FileName.ToLower();
if (lowerFileName.EndsWith(".jpg") || lowerFileName.EndsWith(".png"))
{
filetype = "Image";
}
else if (lowerFileName.EndsWith(".pdf"))
{
filetype = "PDF";
}
string filepath = Path.Combine(HttpContext.Server.MapPath("~/Content/UploatAttachment"), SaveFileName);
FileInfo fileInfo = new FileInfo(filepath);
string fileSize = _commonHelper.FormatBytes(fileInfo.Length);
var file = new GTFile
{
UserID = UserId,
UserName = UserName,
GTID = Id,
GTType = GTType,
FileName = FileName,
SaveFileName = SaveFileName,
FileType = filetype,
FileSize = fileSize
};
_gtFileRepository.Save(file);
return(Json(file, JsonRequestBehavior.AllowGet));
}
private void GenerateKeyProvider(UnityPath p)
{
_aes.GenerateKey();
_aes.GenerateIV();
_sb.Clear();
using (GTFile f = new GTFile(_sb, p, Encoding.UTF8))
{
using (GTUsings u = f.Generate_Usings <GTUsings>())
{
u.SetRequired("HexCS.Encryption");
}
using (GTNamespace n = f.Generate_Namespace <GTNamespace>())
{
n.SetRequired(_namespace);
using (GTClass cls = n.Generate_NamespaceObject <GTClass>())
{
cls.SetRequired(_fileName.String, EKeyword.PUBLIC);
cls.Add_Inheritances("AKeyProviderAesSource");
using (GTProperty_GetOnly key = cls.Generate_Property <GTProperty_GetOnly>())
{
key.SetRequired("byte[]", "Key", EKeyword.PUBLIC, EKeyword.OVERRIDE);
using (GTValue_ArrayInitializer ar = key.Generate_DefaultValue <GTValue_ArrayInitializer>())
{
ar.SetRequired("byte");
foreach (byte b in _aes.Key)
{
ar.Generate_Value <GTValue>().SetRequired(b.ToString());
}
}
}
using (GTProperty_GetOnly iv = cls.Generate_Property <GTProperty_GetOnly>())
{
iv.SetRequired("byte[]", "Iv", EKeyword.PUBLIC, EKeyword.OVERRIDE);
using (GTValue_ArrayInitializer ar = iv.Generate_DefaultValue <GTValue_ArrayInitializer>())
{
ar.SetRequired("byte");
foreach (byte b in _aes.IV)
{
ar.Generate_Value <GTValue>().SetRequired(b.ToString());
}
}
}
}
}
}
AssetDatabase.Refresh();
}
public ActionResult ChooseFileGT(string Id, string GTType, string ids)
{
string[] idList = ids.Split(new string[] { "," }, StringSplitOptions.RemoveEmptyEntries);
var files = _fileRepository.FindBy(x => idList.Contains(x.Id)).ToList();
int exists = 0;
int added = 0;
var gtFiles = new List <GTFile>();
foreach (var file in files)
{
var gt = _gtFileRepository.GetSingle(x => x.SaveFileName == file.SaveFileName && x.GTID == Id);
if (gt != null)
{
exists++;
continue;
}
var gtfile = new GTFile
{
UserID = UserId,
UserName = UserName,
GTID = Id,
GTType = GTType,
FileName = file.FileName,
SaveFileName = file.SaveFileName,
FileType = file.FileType,
FileSize = file.FileSize
};
gtFiles.Add(gtfile);
added++;
}
_gtFileRepository.AddMany(gtFiles);
return(Json(new { exists = exists, added = added }, JsonRequestBehavior.AllowGet));
}
/// <summary>
/// Generates the generic event files associated with the EventGenerationArgs at the path specified
/// </summary>
/// <param name="sb"></param>
/// <param name="folderPath"></param>
/// <param name="args"></param>
public static void GenerateGenericEvents(this EventGenerationArgs args, StringBuilder sb, PathString folderPath)
{
// The Unity Event File
sb.Clear();
using (GTFile file = new GTFile(sb, folderPath.InsertAtEnd($"{args.UnityEvtName}.cs"), Encoding.UTF8))
{
using (GTUsings us = file.Generate_Usings <GTUsings>())
{
List <string> usings = new List <string>();
usings.Add("HexUN.Events");
usings.Add("UnityEngine");
usings.Add("UnityEngine.Events");
if (args.EvtTypeNamespace != null)
{
usings.Add(args.EvtTypeNamespace);
}
us.Add_Usings(usings.Where(u => u != args.EvtNamespace).Distinct().ToArray());
}
using (GTNamespace nm = file.Generate_Namespace <GTNamespace>())
{
nm.SetRequired(args.EvtNamespace);
using (GTClass cls = nm.Generate_NamespaceObject <GTClass>())
{
cls.SetRequired(args.UnityEvtName, EKeyword.PUBLIC);
cls.Generate_Attribute <GTAttribute>().SetRequired("System.Serializable");
cls.Add_Inheritances(
$"UnityEvent<{args.EvtType}>"
);
}
}
}
// The Reliable Event File
sb.Clear();
using (GTFile file = new GTFile(sb, folderPath.InsertAtEnd($"{args.ReliableEvtName}.cs"), Encoding.UTF8))
{
using (GTUsings us = file.Generate_Usings <GTUsings>())
{
List <string> usings = new List <string>();
usings.Add("HexUN.Events");
if (args.EvtTypeNamespace != null)
{
usings.Add(args.EvtTypeNamespace);
}
us.Add_Usings(usings.Where(u => u != args.EvtNamespace).Distinct().ToArray());
}
using (GTNamespace nm = file.Generate_Namespace <GTNamespace>())
{
nm.SetRequired(args.EvtNamespace);
using (GTClass cls = nm.Generate_NamespaceObject <GTClass>())
{
cls.SetRequired(args.ReliableEvtName, EKeyword.PUBLIC);
cls.Generate_Attribute <GTAttribute>().SetRequired("System.Serializable");
cls.Add_Inheritances(
$"ReliableEvent<{args.EvtType}, {args.UnityEvtName}>"
);
}
}
}
//// The Event Listener File
//sb.Clear();
//using (GTFile file = new GTFile(sb, folderPath.AddStep($"{args.EvtListenerName}.cs"), Encoding.UTF8))
//{
// using (GTUsings us = file.Generate_Usings<GTUsings>())
// {
// List<string> usings = new List<string>();
// usings.Add("UnityEngine");
// usings.Add("HexUN.Events");
// if (args.EvtTypeNamespace != null) usings.Add(args.EvtTypeNamespace);
// us.Add_Usings(usings.Where(u => u != args.EvtNamespace).Distinct().ToArray());
// }
// using (GTNamespace nm = file.Generate_Namespace<GTNamespace>())
// {
// nm.SetRequired(args.EvtNamespace);
// using (GTClass cls = nm.Generate_NamespaceObject<GTClass>())
// {
// using (GTAttribute att = cls.Generate_Attribute<GTAttribute>())
// {
// att.SetRequired("AddComponentMenu");
// att.Add_Args(new Arg_Basic($"\"{args.MenuPath}/{args.ReadableEvtType}/{args.EvtListenerName}\""));
// }
// cls.SetRequired(args.EvtListenerName, EKeyword.PUBLIC);
// cls.Add_Inheritances(
// $"EventListener<{args.EvtType}, {args.UnityEvtName}>"
// );
// }
// }
//}
}
/// <summary>
/// Generates the scriptable object event files associated with the given EventGenerationArgs at the path specified
/// </summary>
/// <param name="args"></param>
/// <param name="sb"></param>
/// <param name="folderPath"></param>
public static void GenerateSOEvents(this EventGenerationArgs args, StringBuilder sb, PathString folderPath)
{
sb.Clear();
// Generate the SO Event file
using (GTFile file = new GTFile(sb, folderPath.InsertAtEnd($"{args.SoEvtName}.cs"), Encoding.UTF8))
{
using (GTUsings us = file.Generate_Usings <GTUsings>())
{
List <string> usings = new List <string>();
usings.Add("UnityEngine");
usings.Add("HexUN.Events");
if (args.EvtTypeNamespace != null)
{
usings.Add(args.EvtTypeNamespace);
}
us.Add_Usings(usings.Where(u => u != args.EvtNamespace).Distinct().ToArray());
}
using (GTNamespace nm = file.Generate_Namespace <GTNamespace>())
{
nm.SetRequired(args.EvtNamespace);
using (GTClass cls = nm.Generate_NamespaceObject <GTClass>())
{
using (GTAttribute attr = cls.Generate_Attribute <GTAttribute>())
{
attr.SetRequired("CreateAssetMenu");
attr.Add_Args(
new Arg_Named("fileName", $"\"{args.SoEvtName}\""),
new Arg_Named("menuName", $"\"{args.MenuPath}/{args.ReadableEvtType}\"")
);
}
cls.SetRequired(args.SoEvtName, EKeyword.PUBLIC);
cls.Add_Inheritances(
$"ScriptableObjectEvent<{args.EvtType}>"
);
}
}
}
// Generate the SO Event Listener file
sb.Clear();
using (GTFile file = new GTFile(sb, folderPath.InsertAtEnd($"{args.SoEvtListenerName}.cs"), Encoding.UTF8))
{
using (GTUsings us = file.Generate_Usings <GTUsings>())
{
List <string> usings = new List <string>();
usings.Add("HexUN.Events");
usings.Add("UnityEngine");
usings.Add("UnityEngine.Events");
if (args.EvtTypeNamespace != null)
{
usings.Add(args.EvtTypeNamespace);
}
us.Add_Usings(usings.Where(u => u != args.EvtNamespace).Distinct().ToArray());
}
using (GTNamespace nm = file.Generate_Namespace <GTNamespace>())
{
nm.SetRequired(args.EvtNamespace);
using (GTClass cls = nm.Generate_NamespaceObject <GTClass>())
{
using (GTAttribute att = cls.Generate_Attribute <GTAttribute>())
{
att.SetRequired("AddComponentMenu");
att.Add_Args(new Arg_Basic($"\"{args.MenuPath}/{args.ReadableEvtType}/{args.SoEvtListenerName}\""));
}
cls.SetRequired(args.SoEvtListenerName, EKeyword.PUBLIC);
cls.Add_Inheritances(
$"ScriptableObjectEventListener<{args.EvtType}, {args.SoEvtName}, {args.UnityEvtName}>"
);
}
}
}
}
public ActionResult Share(string gids, string tids, string cids, string type, string fid, string GTId, string GTType)
{
string[] gidsList = gids.Split(new string[] { "," }, StringSplitOptions.RemoveEmptyEntries);
string[] tidsList = tids.Split(new string[] { "," }, StringSplitOptions.RemoveEmptyEntries);
string[] cidsList = cids.Split(new string[] { "," }, StringSplitOptions.RemoveEmptyEntries);
var file = new FileCommonViewModel();
if (GTType == "File" && type == "File")
{
file = _mapper.Map <Core.Entities.File, FileCommonViewModel>(_fileRepository.GetSingle(fid));
}
else if (GTType != "File" && type == "File")
{
file = _mapper.Map <GTFile, FileCommonViewModel>(_gtFileRepository.GetSingle(fid));
}
var gtFiles = new List <GTFile>();
var files = new List <Core.Entities.File>();
foreach (string gid in gidsList)
{
var item = new GTFile
{
UserID = UserId,
UserName = UserName,
GTID = gid,
GTType = "Group",
FileName = file.FileName,
SaveFileName = file.SaveFileName,
FileType = file.FileType,
FileSize = file.FileSize
};
gtFiles.Add(item);
}
foreach (string tid in tidsList)
{
var item = new GTFile
{
UserID = UserId,
UserName = UserName,
GTID = tid,
GTType = "Team",
FileName = file.FileName,
SaveFileName = file.SaveFileName,
FileType = file.FileType,
FileSize = file.FileSize
};
gtFiles.Add(item);
}
foreach (string cid in cidsList)
{
var item = new Core.Entities.File
{
UserID = cid,
FileName = file.FileName,
SaveFileName = file.SaveFileName,
FileType = file.FileType,
FileSize = file.FileSize
};
files.Add(item);
}
_fileRepository.AddMany(files);
_gtFileRepository.AddMany(gtFiles);
return(Json(true, JsonRequestBehavior.AllowGet));
}
public ActionResult SaveUploadFile(string FileName, string SaveFileName, string FolderID, string Id, string GTType)
{
string filetype = "Other";
string lowerFileName = FileName.ToLower();
if (lowerFileName.EndsWith(".jpg") || lowerFileName.EndsWith(".png"))
{
filetype = "Image";
}
else if (lowerFileName.EndsWith(".pdf"))
{
filetype = "PDF";
}
string filepath = Path.Combine(HttpContext.Server.MapPath("~/Content/UploatAttachment"), SaveFileName);
FileInfo fileInfo = new FileInfo(filepath);
string fileSize = _commonHelper.FormatBytes(fileInfo.Length);
int width = 0, height = 0;
if (filetype == "Image")
{
Image img = Image.FromFile(filepath);
width = img.Width;
height = img.Height;
}
if (GTType == "File")
{
var file = new Core.Entities.File
{
UserID = UserId,
FileName = FileName,
SaveFileName = SaveFileName,
FolderID = FolderID,
FileType = filetype,
FileSize = fileSize,
Width = width,
Height = height,
};
_fileRepository.Save(file);
return(Json(file, JsonRequestBehavior.AllowGet));
}
else
{
var file = new GTFile
{
UserID = UserId,
UserName = UserName,
GTID = Id,
GTType = GTType,
FolderID = FolderID,
FileName = FileName,
SaveFileName = SaveFileName,
FileType = filetype,
FileSize = fileSize,
Width = width,
Height = height,
};
_gtFileRepository.Save(file);
return(Json(file, JsonRequestBehavior.AllowGet));
}
}
