/// <summary>
/// 根据条件筛选所有Menu指定页码的数据（分页型）
/// </summary>
/// <param name="menu">实体对象</param>
/// <param name="pageparams">分页对象</param>
/// <param name="totalCount">符合条件的记录总数量</param>
/// <returns></returns>
public DataSet GetData(EntityMenu menu, PageParams pageparams, out int totalCount)
{
#region
DBConditions querybusinessparams = new DBConditions(pageparams);
querybusinessparams.Add(MenuData.menuId, EnumSqlType.sqlint,
EnumCondition.Equal, menu.menuId);
querybusinessparams.Add(MenuData.currentId, EnumSqlType.sqlint,
EnumCondition.Equal, menu.currentId);
querybusinessparams.Add(MenuData.parentId, EnumSqlType.sqlint,
EnumCondition.Equal, menu.parentId);
querybusinessparams.Add(MenuData.menuName, EnumSqlType.nvarchar,
EnumCondition.Equal, menu.menuName);
querybusinessparams.Add(MenuData.iconCls, EnumSqlType.nvarchar,
EnumCondition.Equal, menu.iconCls);
querybusinessparams.Add(MenuData.htmlurl, EnumSqlType.nvarchar,
EnumCondition.Equal, menu.htmlurl);
querybusinessparams.Add(MenuData.eventName, EnumSqlType.nvarchar,
EnumCondition.Equal, menu.eventName);
querybusinessparams.Add(MenuData.sort, EnumSqlType.sqlint,
EnumCondition.Equal, menu.sort);
querybusinessparams.Add(MenuData.usable, EnumSqlType.bit,
EnumCondition.Equal, menu.usable);
MenuData menudata = new MenuData();
totalCount = this._menuclass.GetSingleT(menudata, querybusinessparams);
return(menudata);
#endregion
}
public void SaveEntityMenu(EntityMenu entityMenu)
{
using (DeepBlueEntities context = new DeepBlueEntities()) {
if (entityMenu.EntityMenuID == 0) {
if (context.EntityMenus.Count() > 0)
entityMenu.SortOrder = context.EntityMenus.Select(em => em.EntityMenuID).Max() + 1;
else
entityMenu.SortOrder = 1;
context.EntityMenus.AddObject(entityMenu);
}
else {
// Define an ObjectStateEntry and EntityKey for the current object.
EntityKey key = default(EntityKey);
object originalItem = null;
key = context.CreateEntityKey("EntityMenus", entityMenu);
// Get the original item based on the entity key from the context
// or from the database.
if (context.TryGetObjectByKey(key, out originalItem)) {
// Call the ApplyCurrentValues method to apply changes
// from the updated item to the original version.
context.ApplyCurrentValues(key.EntitySetName, entityMenu);
}
}
context.SaveChanges();
}
}
/// <summary>
/// Get recipes categories
/// </summary>
/// <param name="items">list items which have a parent id</param>
/// <param name="thisEntity">parent element</param>
/// <param name="level">level hierarchy</param>
/// <param name="levelLimitation">level limitation hierarchy</param>
public void BuildRecipesCategories(List <EntityMenu> items, Category thisEntity, int level, int levelLimitation)
{
if (level > levelLimitation)
{
return;
}
items.Add(new EntityMenu()
{
Id = thisEntity.Id, Name = $"{new string('-', level)}{thisEntity.Name}", ParentId = thisEntity.ParentId
});
foreach (var recipe in RecipeRepository.Items.Where(x => x.IdCategory == thisEntity.Id))
{
items.Add(new EntityMenu()
{
Id = recipe.Id, Name = $" {recipe.Name}", ParentId = recipe.IdCategory, TypeEntity = "recipe"
});
}
foreach (var child in CategoryRepository.Items.FindAll((x) => x.ParentId == thisEntity.Id).OrderBy(x => x.Name))
{
var entityMenu = new EntityMenu()
{
Id = child.Id, Name = child.Name, ParentId = child.ParentId
};
BuildCurrentOpenRecipesCategories(items, entityMenu, level + 1, levelLimitation);
}
}
// PUT api/entitymenu/
public HttpResponseMessage Put([FromBody] EntityMenu value, string filter = null)
{
ServerValidationInfo vi = null;
value.UpdateDate = DateTime.Now;
value.CreateDate = DateTime.Now;
if (!ModelState.IsValid)
{
vi = new ServerValidationInfo(ModelState);
}
if (filter == null)
{
context.Entry(value).State = System.Data.EntityState.Modified;
}
else
{
var old = context.EntityMenus.SingleOrDefault(queryBuider.CreateWhere(filter));
old.Id = value.Id;
old.Name = value.Name;
old.EntityId = value.EntityId;
old.IsSpecial = value.IsSpecial;
old.IsAvailable = value.IsAvailable;
old.ImageId = value.ImageId;
old.UpdateUserId = value.UpdateUserId;
old.UpdateDate = value.UpdateDate;
old.CreateDate = value.CreateDate;
}
if (vi != null && vi.ContainsError)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, vi));
}
var result = context.SaveChanges() > 0;
return(Request.CreateResponse(HttpStatusCode.OK, result));
}
/****************************************
***生成器版本：V1.0.1.31494
***生成时间：2013-04-06 17:31:07
***公司：山西ICat Studio有限公司
***友情提示：以下代码为生成器自动生成，可做参照修改之用；
*** 如需有其他业务要求，可在region外添加新方法；
*** 如发现任何编译和运行时错误，请联系QQ：330669393。
*****************************************/
#region public members methods
/// <summary>
/// 根据条件筛选所有Menu指定页码的数据（分页型）
/// </summary>
/// <param name="menu">实体对象</param>
/// <param name="pageparams">分页对象</param>
/// <returns></returns>
public string GetJsonByPage(EntityMenu menu, PageParams pageparams)
{
#region
int totalCount = 0;
DataSet menudata = this.GetData(menu, pageparams, out totalCount);
return(base.GetJson(menudata, totalCount));
#endregion
}
/// <summary>
/// 将符合查询的数据导出Excel
/// </summary>
/// <param name="filename"></param>
/// <param name="grid"></param>
/// <param name="httplink"></param>
public void OutputExcel(string filename, ExtjsGrid grid, EntityMenu menu)
{
#region
int totalcount = 0;
PageParams queryparams = new PageParams(1, 65536);
DataSet ds = this.GetData(menu, queryparams, out totalcount);
ExportExcel exportexcel = new ExportExcel(filename, ds, grid);
exportexcel.Output();
#endregion
}
/// <summary>
/// Get recipes for the currently open category only
/// </summary>
/// <param name="items">list items which have a parent id</param>
/// <param name="thisEntity">item which have ParentId 0</param>
/// <param name="level">level hierarchy</param>
/// <param name="levelLimitation">level limitation hierarchy</param>
private void BuildCurrentOpenRecipesCategories(List <EntityMenu> items, EntityMenu thisEntity, int level, int levelLimitation)
{
if (level <= levelLimitation)
{
items.Add(new EntityMenu()
{
Id = thisEntity.Id, Name = $"{new string('-', level)}{thisEntity.Name}", ParentId = thisEntity.ParentId
});
foreach (var child in items.FindAll((x) => x.ParentId == thisEntity.Id).OrderBy(x => x.Id))
{
BuildCurrentOpenRecipesCategories(items, child, level + 1, levelLimitation);
}
}
}
public static Sprite GetEntityMenuSprite(EntityMenu menuId)
{
EditorEntityButton selectedMenu;
if (_instance.entityMatchDic.TryGetValue(menuId, out selectedMenu))
{
SpriteRenderer sr = selectedMenu.GetComponent <SpriteRenderer>();
if (sr != null)
{
return(sr.sprite);
}
}
return(null);
}
/// <summary>
/// 添加Menu表行数据（如主键为非自增型字段，则自行修改代码）
/// </summary>
/// <param name="menudata">数据集对象</param>
/// <param name="menu">实体对象</param>
public void AddRow(ref MenuData menudata, EntityMenu menu)
{
#region
DataRow dr = menudata.Tables[0].NewRow();
menudata.Assign(dr, MenuData.menuId, menu.menuId);
menudata.Assign(dr, MenuData.currentId, menu.currentId);
menudata.Assign(dr, MenuData.parentId, menu.parentId);
menudata.Assign(dr, MenuData.menuName, menu.menuName);
menudata.Assign(dr, MenuData.iconCls, menu.iconCls);
menudata.Assign(dr, MenuData.htmlurl, menu.htmlurl);
menudata.Assign(dr, MenuData.eventName, menu.eventName);
menudata.Assign(dr, MenuData.sort, menu.sort);
menudata.Assign(dr, MenuData.usable, menu.usable);
menudata.Tables[0].Rows.Add(dr);
#endregion
}
// POST api/entitymenu/
public HttpResponseMessage Post([FromBody] EntityMenu value)
{
ServerValidationInfo vi = null;
value.UpdateDate = DateTime.Now;
value.CreateDate = DateTime.Now;
if (!ModelState.IsValid)
{
vi = new ServerValidationInfo(ModelState);
}
if (vi != null && vi.ContainsError)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, vi));
}
context.Entry(value).State = System.Data.EntityState.Added;
context.SaveChanges();
return(Request.CreateResponse(HttpStatusCode.OK, value));
}
/// <summary>
/// 编辑menudata数据集中指定的行数据
/// </summary>
/// <param name="menudata">数据集对象</param>
/// <param name="menu">实体对象</param>
public void EditRow(ref MenuData menudata, EntityMenu menu)
{
#region
if (menudata.Tables[0].Rows.Count <= 0)
{
menudata = this.getData(menu.menuId);
}
DataRow dr = menudata.Tables[0].Rows.Find(new object[1] {
menu.menuId
});
menudata.Assign(dr, MenuData.menuId, menu.menuId);
menudata.Assign(dr, MenuData.currentId, menu.currentId);
menudata.Assign(dr, MenuData.parentId, menu.parentId);
menudata.Assign(dr, MenuData.menuName, menu.menuName);
menudata.Assign(dr, MenuData.iconCls, menu.iconCls);
menudata.Assign(dr, MenuData.htmlurl, menu.htmlurl);
menudata.Assign(dr, MenuData.eventName, menu.eventName);
menudata.Assign(dr, MenuData.sort, menu.sort);
menudata.Assign(dr, MenuData.usable, menu.usable);
#endregion
}
/// <summary>
/// Get recipes categories
/// </summary>
/// <param name="items">list items which have a parent id</param>
/// <param name="category">parent element</param>
/// <param name="level">level hierarchy</param>
/// <param name="levelLimitation">level limitation hierarchy</param>
private async Task BuildRecipesCategoriesAsync(List <EntityMenu> items, Category category, int level, int levelLimitation)
{
if (level > levelLimitation)
{
return;
}
if (items != null && category != null)
{
items.Add(new EntityMenu()
{
Id = category.Id, Name = $"{new string('-', level)}{category.Name}", ParentId = category.ParentId
});
List <Recipe> recipes = await _recipesController.GetRecipesWhereCategoryIdAsync(category.Id);
foreach (Recipe recipe in recipes)
{
items.Add(new EntityMenu()
{
Id = recipe.Id, Name = $" {recipe.Name}", ParentId = recipe.CategoryId, TypeEntity = "recipe"
});
}
}
List <Category> categories = await _recipesController.GetCategoriesWhereParentIdAsync(category.Id);
foreach (Category child in categories.OrderBy(x => x.Name))
{
EntityMenu entityMenu = new EntityMenu()
{
Id = child.Id, Name = child.Name, ParentId = child.ParentId
};
if (items != null)
{
await BuildCurrentOpenRecipesCategoryAsync(items, entityMenu, level + 1, levelLimitation);
}
}
}
public ActionResult UpdateEntityMenu(FormCollection collection)
{
ICacheManager cacheManager=new MemoryCacheManager();
EditEntityMenuModel model=new EditEntityMenuModel();
ResultModel resultModel=new ResultModel();
this.TryUpdateModel(model);
//string ErrorMessage = EntityMenuAvailable(model.DisplayName, model.EntityMenuID);
//if (String.IsNullOrEmpty(ErrorMessage) == false) {
// ModelState.AddModelError("DisplayName", ErrorMessage);
//}
if(ModelState.IsValid) {
EntityMenu entityMenu=AdminRepository.FindEntityMenu(model.EntityMenuID);
if(entityMenu==null) {
entityMenu=new EntityMenu();
}
entityMenu.DisplayName=model.DisplayName;
entityMenu.MenuID=model.MenuID;
entityMenu.EntityID=Authentication.CurrentEntity.EntityID;
IEnumerable<ErrorInfo> errorInfo=AdminRepository.SaveEntityMenu(entityMenu);
if(errorInfo!=null) {
resultModel.Result+=ValidationHelper.GetErrorInfo(errorInfo);
} else {
// Remove entity menu cache
cacheManager.RemoveByPattern(string.Format(MenuHelper.ENTITYMENUKEY,entityMenu.EntityID));
resultModel.Result="True||"+entityMenu.EntityMenuID;
}
} else {
foreach(var values in ModelState.Values.ToList()) {
foreach(var err in values.Errors.ToList()) {
if(string.IsNullOrEmpty(err.ErrorMessage)==false) {
resultModel.Result+=err.ErrorMessage+"\n";
}
}
}
}
return View("Result",resultModel);
}
