public string GetAllJob()
{
var listData = MemoryOperator.GetAllJob();
var data = JsonConvert.SerializeObject(listData);
return(data);
}
/// <summary>
/// 读取配置初始化 包列表信息
/// </summary>
/// <param name="data"></param>
/// <param name="offset"></param>
public void Read(byte[] data, ref int offset, bool procDependency = false)
{
int count = MemoryOperator.ReadShort(data, ref offset);
int resCount = 0;
for (int i = 0; i < count; i++)
{
ResPackInfo packInfo = CreatePackInfo(data, ref offset);
if (packInfo != null)
{
packInfo.Read(data, ref offset);
if (procDependency)
{
packInfo.ProcessDependency(PackInfo);
}
PackInfo.Add(packInfo);
resCount += packInfo.Resources.Count;
}
}
if (_resourceMap == null)
{
_resourceMap = new JWObjDictionary <string, ResPackInfo>(resCount, StringComparer.OrdinalIgnoreCase);
}
for (int i = 0; i < PackInfo.Count; ++i)
{
AddToMap(PackInfo[i]);
}
}
/// <summary>
/// 读取配置
/// </summary>
/// <param name="data"></param>
/// <param name="offset"></param>
public void Read(byte[] data, ref int offset)
{
_cachedAssetInfos.Clear();
_cachedAssetInfoMap.Clear();
if (data == null)
{
return;
}
int dataLength = data.Length - offset;
if (dataLength < 6)
{
return;
}
int storedDataLength = MemoryOperator.ReadInt(data, ref offset);
if (storedDataLength < 6 || storedDataLength > dataLength)
{
return;
}
//
int version = MemoryOperator.ReadShort(data, ref offset);
if (version != Version)
{
return;
}
//信息数量
int amount = MemoryOperator.ReadShort(data, ref offset);
for (int i = 0; i < amount; i++)
{
NetAssetInfo info = new NetAssetInfo();
info.Key = MemoryOperator.ReadString(data, ref offset);
info.AssetType = (NetAssetType)MemoryOperator.ReadShort(data, ref offset);
if (info.AssetType == NetAssetType.Image)
{
info.ImageWidth = MemoryOperator.ReadShort(data, ref offset);
info.ImageHeight = MemoryOperator.ReadShort(data, ref offset);
}
//
info.LastModifyTime = MemoryOperator.ReadDateTime(data, ref offset);
//
if (!_cachedAssetInfoMap.ContainsKey(info.Key))
{
_cachedAssetInfoMap.Add(info.Key, info);
_cachedAssetInfos.Add(info);
}
}
//排序
_cachedAssetInfos.Sort();
}
public string GetCountOfDistrictQuantityByYear(List <int> listYear)
{
long count = 0;
if (listYear.Count <= 0)
{
return(JsonConvert.SerializeObject(count));
}
count = listYear.Sum(year => MemoryOperator.GetCountOfDistrictQuantities(year));
return(JsonConvert.SerializeObject(count));
}
public string GetAreaQuantityCustom(int year, string areaName)
{
Area area = MemoryOperator.GetAreaByName(areaName);
if (area == null)
{
return(string.Empty);
}
List <AreaQuantity> listAreaQuantities = MemoryOperator.GetAreaQuantityByYearAndArea(year,
area.Id);
return(JsonConvert.SerializeObject(listAreaQuantities));
}
public string GetProvinceQuantityCustom(int year, string provinceName)
{
Province province = MemoryOperator.GetProvinceByName(provinceName);
if (province == null)
{
return(string.Empty);
}
List <ProvinceQuantity> listProvinceQuantities = MemoryOperator.GetProvinceQuantityByYearAndProvince(year,
province.Id);
return(JsonConvert.SerializeObject(listProvinceQuantities));
}
public string GetBranchQuantityCustom(int year, string branchName)
{
Branch branch = MemoryOperator.GetBranchByName(branchName);
if (branch == null)
{
return(string.Empty);
}
List <BranchQuantity> listBranchQuantities = MemoryOperator.GetBranchQuantityByYearAndBranch(year,
branch.Id);
return(JsonConvert.SerializeObject(listBranchQuantities));
}
public string GetDistrictQuantityCustom(int year, string districtName)
{
District district = MemoryOperator.GetDistrictByName(districtName);
if (district == null)
{
return(string.Empty);
}
List <DistrictQuantity> listDistrictQuantities = MemoryOperator.GetDistrictQuantityByYearAndDistrict(year,
district.Id);
return(JsonConvert.SerializeObject(listDistrictQuantities));
}
public string GetDistrictQuantityByYear(List <int> listYear)
{
var listReturnData = new List <DistrictQuantity>();
if (listYear.Count <= 0)
{
return(JsonConvert.SerializeObject(listReturnData));
}
foreach (var year in listYear)
{
var childDatas = MemoryOperator.GetAllDistrictQuantities(year);
listReturnData.AddRange(childDatas);
}
return(JsonConvert.SerializeObject(listReturnData));
}
/// <summary>
/// 读二进制 配置初始化
/// </summary>
/// <param name="data"></param>
/// <param name="offset"></param>
public virtual void Read(byte[] data, ref int offset)
{
// Path
Path = MemoryOperator.ReadString(data, ref offset);
// resource count
int count = MemoryOperator.ReadShort(data, ref offset);
// resources
for (int i = 0; i < count; i++)
{
ResInfo resource = new ResInfo();
resource.Path = MemoryOperator.ReadString(data, ref offset);
resource.Ext = MemoryOperator.ReadString(data, ref offset);
Resources.Add(resource);
}
// check location
CheckLocation();
}
/// <summary>
/// 读二进制配置初始化
/// </summary>
/// <param name="data"></param>
/// <param name="offset"></param>
public override void Read(byte[] data, ref int offset)
{
base.Read(data, ref offset);
Path = Path.ToLower();
// Flags
Flags = MemoryOperator.ReadInt(data, ref offset);
// Life
Life = (EBundleLife)MemoryOperator.ReadShort(data, ref offset);
// Dependency
int hasDependency = MemoryOperator.ReadByte(data, ref offset);
if (hasDependency == 1)
{
DependencyNames = MemoryOperator.ReadString(data, ref offset);
}
}
/// <summary>
/// 创建包信息
/// </summary>
/// <param name="data"></param>
/// <param name="offset"></param>
/// <returns></returns>
ResPackInfo CreatePackInfo(byte[] data, ref int offset)
{
// type
int type = MemoryOperator.ReadByte(data, ref offset);
switch ((ResPackType)type)
{
case ResPackType.ResPackTypeBundle:
return(new BundlePackInfo());
case ResPackType.ResPackTypeBinary:
return(new BinaryPackInfo());
default:
break;
}
return(null);
}
/// <summary>
/// 写二进制配置
/// </summary>
/// <param name="data"></param>
/// <param name="offset"></param>
public override void Write(byte[] data, ref int offset)
{
base.Write(data, ref offset);
// Flags
MemoryOperator.WriteInt(Flags, data, ref offset);
// Life
MemoryOperator.WriteShort((short)Life, data, ref offset);
// Dependency
if (string.IsNullOrEmpty(DependencyNames))
{
MemoryOperator.WriteByte(0, data, ref offset);
}
else
{
MemoryOperator.WriteByte(1, data, ref offset);
MemoryOperator.WriteString(DependencyNames, data, ref offset);
}
}
public void Write(string buidlDir, string excludePackName = null)
{
List <ResPackInfo> allInfo = _config.PackInfo;
List <ResPackInfo> baseInfo = new List <ResPackInfo>();
if (allInfo != null)
{
for (int i = 0; i < allInfo.Count; ++i)
{
ResPackInfo pack = allInfo[i];
pack.Path = JW.Res.FileUtil.CombinePaths(
"",
pack.Path);
//
if (pack.Path.Equals(excludePackName, StringComparison.OrdinalIgnoreCase))
{
JW.Common.Log.LogD("-->写入包配置信息文件 移除-->" + excludePackName);
continue;
}
else
{
baseInfo.Add(pack);
}
}
}
byte[] buffer = new byte[1024 * 1024];
int offset = 0;
// count
MemoryOperator.WriteShort((short)baseInfo.Count, buffer, ref offset);
// resources
for (int i = 0; i < baseInfo.Count; i++)
{
baseInfo[i].Write(buffer, ref offset);
}
JW.Res.FileUtil.WriteFile(JW.Res.FileUtil.CombinePaths(buidlDir, _outConfigName)
, buffer, 0, offset);
}
/// <summary>
/// 写成配置
/// </summary>
/// <param name="data"></param>
/// <param name="offset"></param>
public void Write(byte[] data, ref int offset)
{
int startOffset = offset;
offset += 4;
MemoryOperator.WriteShort((short)Version, data, ref offset);
MemoryOperator.WriteShort((short)_cachedAssetInfos.Count, data, ref offset);
//
for (int i = 0; i < _cachedAssetInfos.Count; i++)
{
NetAssetInfo info = _cachedAssetInfos[i];
//Key
MemoryOperator.WriteString(info.Key, data, ref offset);
MemoryOperator.WriteShort((short)info.AssetType, data, ref offset);
if (info.AssetType == NetAssetType.Image)
{
MemoryOperator.WriteShort((short)info.ImageWidth, data, ref offset);
MemoryOperator.WriteShort((short)info.ImageHeight, data, ref offset);
}
//最后修改时间
MemoryOperator.WriteDateTime(ref info.LastModifyTime, data, ref offset);
}
MemoryOperator.WriteInt(offset - startOffset, data, ref startOffset);
}
/// <summary>
/// 写二进制配置
/// </summary>
/// <param name="data"></param>
/// <param name="offset"></param>
public virtual void Write(byte[] data, ref int offset)
{
// type
byte type = GetPackType();
MemoryOperator.WriteByte(type, data, ref offset);
// Path
if (type == 0)
{
//小写
MemoryOperator.WriteString(Path.ToLower(), data, ref offset);
}
else
{
MemoryOperator.WriteString(Path, data, ref offset);
}
// resources
MemoryOperator.WriteShort((short)Resources.Count, data, ref offset);
for (int i = 0; i < Resources.Count; i++)
{
MemoryOperator.WriteString(Resources[i].Path, data, ref offset);
MemoryOperator.WriteString(Resources[i].Ext, data, ref offset);
}
}
public string UploadDistrictQuantity(List <DistrictQuantityExcel> listDistrictQuantityExcels)
{
List <DistrictQuantity> listInsert = new List <DistrictQuantity>();
List <DistrictQuantity> listUpdate = new List <DistrictQuantity>();
foreach (var districtQuantityExcel in listDistrictQuantityExcels)
{
DistrictQuantity districtQuantity = new DistrictQuantity();
//set DistrictId
District district = MemoryOperator.GetDistrictByName(districtQuantityExcel.Name);
if (district == null)
{
continue;
}
districtQuantity.DistrictId = district.Id;
//set AgeId
Age age = MemoryOperator.GetAgeByAgeStart(districtQuantityExcel.Age);
if (age == null)
{
continue;
}
districtQuantity.AgeId = age.Id;
//set SexId
Sex sex = MemoryOperator.GetSexBySexName(districtQuantityExcel.Sex);
if (sex == null)
{
continue;
}
districtQuantity.SexId = sex.Id;
//set JobId
Job job = MemoryOperator.GetJobByJobName(districtQuantityExcel.Job);
if (job == null)
{
continue;
}
districtQuantity.JobId = job.Id;
//set year
int year;
if (int.TryParse(districtQuantityExcel.Year, out year))
{
districtQuantity.Year = year;
}
else
{
continue;
}
//set quantity
long quantity;
if (long.TryParse(districtQuantityExcel.Quantity, out quantity))
{
districtQuantity.Quantity = quantity;
}
else
{
continue;
}
//check insert or update
var checkDistrictQuantity = MemoryOperator.CheckExistDistrictQuantity(districtQuantity);
if (checkDistrictQuantity == null)
{
listInsert.Add(districtQuantity);
}
else
{
districtQuantity.Id = checkDistrictQuantity.Id;
listUpdate.Add(districtQuantity);
}
}
MemoryOperator.UpdateMemberThread(listUpdate, listInsert);
return("1");
}
/// 输出子配置文件 用于运行时读取
public void WriteSubCfg(string buildDir, string[] resourcesPrefixs, string cfgFileName, bool excludeMode = false, string cleanLua = "")
{
List <ResPackInfo> allInfo = _config.PackInfo;
List <ResPackInfo> baseInfo = new List <ResPackInfo>();
if (allInfo != null)
{
for (int i = 0; i < allInfo.Count; ++i)
{
ResPackInfo pack = allInfo[i];
pack.Path = JW.Res.FileUtil.CombinePaths(
"",
pack.Path);
bool isIn = false;
//非排他模式
if (excludeMode == false)
{
isIn = false;
for (int j = 0; j < resourcesPrefixs.Length; j++)
{
if (pack.Path.StartsWith(resourcesPrefixs[j]))
{
isIn = true;
break;
}
}
}
else
{
//排他模式
isIn = true;
for (int j = 0; j < resourcesPrefixs.Length; j++)
{
if (pack.Path.StartsWith(resourcesPrefixs[j]))
{
isIn = false;
break;
}
}
}
//Lua脚本包排除
if (!string.IsNullOrEmpty(cleanLua))
{
if (pack.Path.Equals(cleanLua, StringComparison.OrdinalIgnoreCase))
{
isIn = false;
}
}
if (isIn)
{
baseInfo.Add(pack);
}
}
}
byte[] buffer = new byte[1024 * 1024];
int offset = 0;
// count
MemoryOperator.WriteShort((short)baseInfo.Count, buffer, ref offset);
// resources
for (int i = 0; i < baseInfo.Count; i++)
{
baseInfo[i].Write(buffer, ref offset);
}
//保存
JW.Res.FileUtil.WriteFile(JW.Res.FileUtil.CombinePaths(buildDir, cfgFileName)
, buffer, 0, offset);
}
