public static ApiResult <T> Error(string msg = "", ApiEnum status = ApiEnum.Error)
{
return(new ApiResult <T>()
{
Msg = msg, Status = (int)status
});
}
public void HashCodeEqualsTest()
{
var item1 = new ApiEnum <TestEnum>(TestEnum.EnumValue1, TestEnum.EnumValue1.ToString());
var item2 = new ApiEnum <TestEnum>(TestEnum.EnumValue1, TestEnum.EnumValue1.ToString());
Assert.Equal(item1.GetHashCode(), item2.GetHashCode());
}
public string GenerateEnumDefinition(ApiEnum apiEnum)
{
var indent = new Indent();
var builder = new StringBuilder();
var typeNameForEnum = apiEnum.ToCSharpClassName();
if (apiEnum.Deprecation != null)
{
builder.AppendLine(apiEnum.Deprecation.ToCSharpDeprecation());
}
builder.AppendLine($"{indent}[JsonConverter(typeof(EnumStringConverter))]");
builder.AppendLine($"{indent}public enum {typeNameForEnum}");
builder.AppendLine($"{indent}{{");
indent.Increment();
foreach (var value in apiEnum.Values)
{
var identifierForValue = CSharpIdentifier.ForClassOrNamespace(value);
builder.AppendLine($"{indent}[EnumMember(Value = \"{value}\")]");
builder.AppendLine($"{indent}{identifierForValue},");
builder.AppendLine($"{indent}");
}
indent.Decrement();
builder.AppendLine($"{indent}}}");
return(builder.ToString());
}
private string ParseEnum(string key, Newtonsoft.JsonV4.Schema.JsonSchema schema, IDictionary <string, ApiEnum> enums, string description)
{
var name = NetNamingMapper.GetObjectName(key);
var apiEnum = new ApiEnum
{
Name = name,
Description = description,
Values = schema.Enum.Select(e => NetNamingMapper.GetEnumValueName(e.ToString())).ToList()
};
if (enums.ContainsKey(name))
{
if (IsAlreadyAdded(enums, apiEnum))
{
return(name);
}
apiEnum.Name = UniquenessHelper.GetUniqueName(enums, name);
}
enums.Add(apiEnum.Name, apiEnum);
return(apiEnum.Name);
}
public void CaseInsensitiveHashCodeEqualsTest()
{
var item1 = new ApiEnum <TestEnum>(TestEnum.EnumValue1, "enumValue1");
var item2 = new ApiEnum <TestEnum>(TestEnum.EnumValue1, "Enumvalue1");
Assert.Equal(item1.GetHashCode(), item2.GetHashCode());
}
public void ToStringTest()
{
string rawValue = "RawEnumValue1";
var item = new ApiEnum <TestEnum>(TestEnum.EnumValue1, rawValue);
Assert.Equal(rawValue, item.ToString());
}
public void OperatorEqualsTest()
{
var item1 = new ApiEnum <TestEnum>(TestEnum.EnumValue1, TestEnum.EnumValue1.ToString());
var item2 = new ApiEnum <TestEnum>(TestEnum.EnumValue1, TestEnum.EnumValue1.ToString());
Assert.True(item1 == item2);
}
public void ImplicitConversionToEnumTest()
{
var expected = TestEnum.EnumValue2;
TestEnum actual = new ApiEnum <TestEnum>(TestEnum.EnumValue2, TestEnum.EnumValue2.ToString());
Assert.Equal(expected, actual);
}
public void CaseInsensitiveEqualsTest()
{
var item1 = new ApiEnum <TestEnum>(TestEnum.EnumValue1, "enumValue1");
var item2 = new ApiEnum <TestEnum>(TestEnum.EnumValue1, "Enumvalue1");
Assert.True(item1.Equals(item2));
}
public void ImplicitConversionFromStringTest()
{
var expected = new ApiEnum <TestEnum>(TestEnum.EnumValue2);
ApiEnum <TestEnum> actual = "EnumValue2";
Assert.Equal(expected, actual);
}
public void ImplicitConversionToStringTest()
{
string expected = "SomeRawEnumValue";
string actual = new ApiEnum <TestEnum>(TestEnum.EnumValue2, expected);
Assert.Equal(expected, actual);
}
public async Task <IHttpActionResult> GetReport(int id)
{
ResultData result = new ResultData();
try
{
var report = await Task.Run(() => db.Report.FirstOrDefault(c => c.id == id));
if (report == null)
{
return(ErrorResult(ResultCode.Faild, "报告不存在."));
}
var iResult = new { data = report, statusName = ApiEnum.TransferReportStatus(report.Status) };
result = new ResultData {
code = (int)ResultCode.Successed, data = JsonConvert.SerializeObject(iResult)
};
}
catch (Exception ex)
{
result = new ResultData {
code = (int)ResultCode.Faild, msg = ex.Message
};
LogClient.WriteLog(ex.Message, ex);
}
return(Json(result));
}
protected virtual void Process(ApiEnum apiEnum)
{
var enm = CreateHierarchyElementInternal <HierarchyEnum> (this);
enm.Init(apiEnum);
Helpers.AddToList(enm, ref enums);
TypeIndex.Add(enm);
}
public void ConstructorTest()
{
var enum1 = new ApiEnum <TestEnum>(TestEnum.EnumValue2);
var enum2 = new ApiEnum <TestEnum>(TestEnum.EnumValue2, null);
Assert.Equal(TestEnum.EnumValue2, enum1.Value);
Assert.Equal(TestEnum.EnumValue2, enum2.Value);
}
public void NotEqualsTest()
{
var item1 = new ApiEnum <TestEnum>(TestEnum.EnumValue1, TestEnum.EnumValue1.ToString());
var item2 = new ApiEnum <TestEnum>(TestEnum.EnumValue1, TestEnum.EnumValue2.ToString());
var item3 = new ApiEnum <TestEnum>(TestEnum.EnumValue2, TestEnum.EnumValue2.ToString());
Assert.False(item1.Equals(item2));
Assert.False(item1.Equals(item3));
Assert.False(item2.Equals(item3));
Assert.False(item1.Equals(new object()));
Assert.False(item1.Equals(null !));
}
public void OperatorNotEqualsTest()
{
var item1 = new ApiEnum <TestEnum>(TestEnum.EnumValue1, TestEnum.EnumValue1.ToString());
var item2 = new ApiEnum <TestEnum>(TestEnum.EnumValue1, TestEnum.EnumValue2.ToString());
var item3 = new ApiEnum <TestEnum>(TestEnum.EnumValue2, TestEnum.EnumValue2.ToString());
Assert.True(item1 != item2);
Assert.True(item1 != item3);
Assert.True(item2 != item3);
#pragma warning disable CS0253 // Possible unintended reference comparison; right hand side needs cast
Assert.True(item1 != new object());
#pragma warning restore CS0253 // Possible unintended reference comparison; right hand side needs cast
Assert.True(item1 != null !);
}
public void IsUnknownTest()
{
var wrapper = new ApiEnum <TestEnum>(TestEnum.EnumValue1, "SomeRandomValue");
Assert.True(wrapper.IsUnknown);
wrapper = new ApiEnum <TestEnum>(TestEnum.EnumValue1, TestEnum.EnumValue1.ToString());
Assert.False(wrapper.IsUnknown);
wrapper = new ApiEnum <TestEnum>(TestEnum.EnumValue1, "enumValue1");
Assert.False(wrapper.IsUnknown);
wrapper = new ApiEnum <TestEnum>(TestEnum.EnumValue1, "enum_value_1");
Assert.False(wrapper.IsUnknown);
}
public IHttpActionResult AuditReport()
{
ResultData result = new ResultData();
try
{
int id = Convert.ToInt32(HttpContext.Current.Request["id"]);
int status = Convert.ToInt32(HttpContext.Current.Request["status"]);
var report = db.Report.FirstOrDefault(en => en.id == id);
if (report == null)
{
return(ErrorResult(ResultCode.Faild, "报告不存在."));
}
report.Status = status;
if (status == 1 || status == 2)
{
report.VerifyFirstDate = DateTime.Now;
}
if (status == 3 || status == 4)
{
report.VerifyLastDate = DateTime.Now;
}
db.Entry(report).State = System.Data.Entity.EntityState.Modified;
int res = db.SaveChanges();
if (res > 0)
{
var iResult = new { data = report, statusName = ApiEnum.TransferReportStatus(report.Status) };
result = new ResultData
{
code = (int)ResultCode.Successed,
msg = ApiEnum.TransferResultCode(ResultCode.Successed),
data = JsonConvert.SerializeObject(iResult)
};
}
}
catch (Exception ex)
{
LogClient.WriteLog(ex.Message, ex);
result = new ResultData()
{
code = (int)ResultCode.Faild, msg = ApiEnum.TransferResultCode(ResultCode.Faild)
};
}
return(Json(result));
}
public IHttpActionResult GetPageDZReport(int pageIndex, string title)
{
ResultData result = new ResultData();
try
{
if (!string.IsNullOrEmpty(HttpContext.Current.Request["pageSize"]))
{
pageSize = int.Parse(HttpContext.Current.Request["pageSize"]);
}
var query = (from c in db.DZReport.AsEnumerable()
where !string.IsNullOrEmpty(c.Title)
orderby c.Seq
select new
{
id = c.id,
title = c.Title,
category = c.Category,
cName = ApiEnum.TransferDZCategory(c.Category),
price = c.Price,
previewPage = c.PreviewPage,
hyfl = c.hyfl,
filePath = c.FilePath
});
var dItems = query.Skip(pageSize * (pageIndex - 1)).Take(pageSize).ToList();
result = new ResultData()
{
code = (int)ResultCode.Successed,
pageIndex = pageIndex,
total = query.Count(),
data = JsonConvert.SerializeObject(dItems)
};
}
catch (Exception ex)
{
result = new ResultData()
{
code = (int)ResultCode.Faild, msg = ex.Message
};
LogClient.WriteLog(ex.Message, ex);
}
return(Json(result));
}
private bool IsAlreadyAdded(IDictionary <string, ApiEnum> enums, ApiEnum apiEnum)
{
foreach (var @enum in enums)
{
if (apiEnum.Values.Count != @enum.Value.Values.Count)
{
continue;
}
if (apiEnum.Values.Any(x => [email protected](x)))
{
continue;
}
return(true);
}
return(false);
}
public IHttpActionResult SaveReport()
{
ResultData result = new ResultData();
List <string> message = new List <string>();
try
{
HttpContext context = HttpContext.Current; //var title = HttpContext.Current.Request["title"];
if (!TextValidation(context, out message))
{
result = new ResultData {
code = (int)ResultCode.Faild, msg = String.Join(",", message)
};
return(Json(result));
}
if (!string.IsNullOrEmpty(context.Request["id"]))
{
EditReport(context); // edit
}
else
{
CreateReport(context); // add
}
int res = db.SaveChanges();
if (res > 0)
{
result = new ResultData()
{
code = (int)ResultCode.Successed, msg = ApiEnum.TransferResultCode(ResultCode.Successed)
};
}
}
catch (Exception ex)
{
LogClient.WriteLog(ex.Message, ex);
result = new ResultData()
{
code = (int)ResultCode.Faild, msg = ApiEnum.TransferResultCode(ResultCode.Faild)
};
}
return(Json(result));
}
public override void Init(ApiElement apiElement)
{
base.Init(apiElement);
apiEnum = EnsureApiElementType <ApiEnum> (apiElement);
// Enums are special - their name attribute is set to the full managed name
int lastDot = apiElement.Name.LastIndexOf('.');
if (lastDot < 0)
{
return;
}
if (lastDot == 0)
{
throw new InvalidOperationException($"Type name ({apiElement.Name}) must not start with a dot");
}
FullName = Name;
Name = apiElement.Name.Substring(lastDot + 1);
}
public async Task <IHttpActionResult> GetPageDirectory(int pageIndex)
{
ResultData result = new ResultData();
try
{
var query = (from c in db.Directory.AsEnumerable()
where !string.IsNullOrEmpty(c.Title)
orderby c.PublishDate descending
select new
{
id = c.id,
title = c.Title,
hyfl = c.hyfl,
publishDate = c.PublishDate,
sendLastDate = c.SendLastDate
});
var dItem = await Task.Run(() => query.Skip(pageSize * (pageIndex - 1)).Take(pageSize).ToList());
result = new ResultData
{
code = (int)ResultCode.Successed,
pageIndex = pageIndex,
total = query.Count(),
data = JsonConvert.SerializeObject(dItem)
};
}
catch (Exception ex)
{
result = new ResultData()
{
code = (int)ResultCode.Faild, msg = ApiEnum.TransferResultCode(ResultCode.Faild)
};
}
return(Json <ResultData>(result));
}
public IHttpActionResult RemoveReport(string ids)
{
ResultData result = new ResultData();
try
{
if (string.IsNullOrEmpty(ids))
{
return(ErrorResult(ResultCode.Faild, "参数值为空，请刷新后重试."));
}
var arrIds = ids.Split(',').Where(en => !string.IsNullOrEmpty(en));
var reports = db.resource_info.Where(en => arrIds.Contains(en.rec_id.ToString()));
if (reports.Count() == 0)
{
return(ErrorResult(ResultCode.Faild, "报告不存在，请刷新后重试."));
}
db.resource_info.RemoveRange(reports);
int res = db.SaveChanges();
if (res > 0)
{
result = new ResultData()
{
code = (int)ResultCode.Successed, msg = ApiEnum.TransferResultCode(ResultCode.Successed)
};
}
}
catch (Exception ex)
{
result = new ResultData {
code = (int)ResultCode.Faild, msg = ApiEnum.TransferResultCode(ResultCode.Faild)
};
LogClient.WriteLog(ex.Message, ex);
}
return(Json <ResultData>(result));
}
private bool HasPermission(TokenInfo TokenInfo, ApiEnum <TokenPermission> Permission)
{
return(TokenInfo.Permissions.Contains(Permission));
}
public void IsUnknownTest(TestEnum @enum, string @string, bool expected)
{
var wrapper = new ApiEnum <TestEnum>(@enum, @string);
Assert.Equal(expected, wrapper.IsUnknown);
}
private string ParseEnum(string key, Newtonsoft.JsonV4.Schema.JsonSchema schema, IDictionary<string, ApiEnum> enums, string description)
{
var name = NetNamingMapper.GetObjectName(key);
var apiEnum = new ApiEnum
{
Name = name,
Description = description,
Values = schema.Enum.Select(e => NetNamingMapper.GetEnumValueName(e.ToString())).ToList()
};
if (enums.ContainsKey(name))
{
if(IsAlreadyAdded(enums, apiEnum))
return name;
apiEnum.Name = UniquenessHelper.GetUniqueName(enums, name);
}
enums.Add(apiEnum.Name, apiEnum);
return apiEnum.Name;
}
public static string ToCSharpClassName(this ApiEnum subject) => CSharpIdentifier.ForClassOrNamespace(subject.Name);
public override void Write(Utf8JsonWriter writer, ApiEnum <T> value, JsonSerializerOptions options) =>
throw new NotImplementedException("TODO: This should generally not be used since we only deserialize stuff from the API, and not serialize to it. Might add support later.");
private bool IsAlreadyAdded(IDictionary<string, ApiEnum> enums, ApiEnum apiEnum)
{
foreach (var @enum in enums)
{
if(apiEnum.Values.Count != @enum.Value.Values.Count)
continue;
if (apiEnum.Values.Any(x => [email protected](x)))
continue;
return true;
}
return false;
}
