public void ComparisonMenu(List <MenuResponse> list, MenuResponse menu)
{
if (list != null)
{
foreach (MenuResponse menuitem in list)
{
if (menu.Id != menuitem.Id)
{
ComparisonMenu(menuitem.Children, menu);
}
else
{
menu.IsCheck = true;
foreach (FunctionSortInfo fun in menu.Functions)
{
foreach (FunctionSortInfo f in menuitem.Functions)
{
if (fun.Id == f.Id)
{
fun.IsCheck = true;
}
}
}
}
}
}
}
private List <dynamic> GetMultiLanguagesForMenuItems(MenuResponse result)
{
List <dynamic> menus = new List <dynamic>();
try {
if (!string.IsNullOrEmpty(result.Menus))
{
dynamic menuJson = JsonConvert.DeserializeObject(result.Menus);
if (menuJson != null)
{
foreach (var menuItem in menuJson)
{
if (menuItem["Text"] != null && menuItem["Text"].Value != null)
{
menuItem["Text"] = SM.GetString(menuItem["Text"].Value);
}
if (menuItem["TranCode"] != null && menuItem["TranCode"].Value != null)
{
menuItem["TranCode"] = SM.GetString(menuItem["TranCode"].Value);
}
menus.Add(menuItem);
}
}
}
}
catch (Exception ex) {
log.ErrorFormat("{0}-{1}-{2}", "Error while getting ML for menus !", "CredentialService-GetMultiLanguagesForApplications", ex);
}
return(menus);
}
/// <summary>
/// Returns the asteroid belts in the currently open menu
/// </summary>
/// <returns>List of menu entries representing the asteroid belts</returns>
public List <MenuEntry> getBelts()
{
List <MenuEntry> belts = new List <MenuEntry>();
BooleanResponse menuOpen = (BooleanResponse)comm.sendCall(FunctionCallFactory.CALLS.ISMENUOPEN, Response.RESPONSES.BOOLEANRESPONSE);
if (menuOpen == null)
{
return(null);
}
if (!(Boolean)menuOpen.Data)
{
return(null);
}
MenuResponse resp = (MenuResponse)comm.sendCall(FunctionCallFactory.CALLS.GETMENUITEMS, Response.RESPONSES.MENURESPONSE);
if (resp == null)
{
Console.WriteLine("couldn't get menu items");
return(null);
}
foreach (MenuEntry entry in (List <MenuEntry>)resp.Data)
{
if (entry.Text.ToLower().Contains("belt "))
{
belts.Add(entry);
}
}
return(belts);
}
/// <summary>
/// xem chi tiết menu
/// </summary>
/// <param name="menuId"></param>
/// <returns></returns>
public async Task <Response <MenuResponse> > GetMenuByIdAsync(Guid menuId)
{
var menu = await _newsContext.Menus.FindAsync(menuId);
if (menu == null)
{
_logger.LogError("Not find menu");
return(new Response <MenuResponse>(Constant.STATUS_ERROR, new List <string> {
"Not find menu"
}));
}
var dataResponse = new MenuResponse
{
Id = menu.Id,
MenuName = menu.MenuName,
Href = menu.Href,
Icon = menu.Icon,
ParentId = menu.ParentId,
Role = await GetRolesAsync(menu.Id),
SubMenus = await GetSubMenusAsync(menu.Id)
};
return(new Response <MenuResponse>(Constant.STATUS_SUCESS, null, dataResponse, 1));
}
public MenuResponse Execute(int id)
{
var menuResponse = new MenuResponse();
try
{
Log.Information("Eliminando el Menu por Id:[{Id}]...", id);
var toDelete = Repository.SingleOrDefault(menu => menu.Id == id);
if (toDelete == null)
{
var exception = new Exception($"Menu no encontrado por Id:[{id}].");
Log.Error(exception, EXCEPTION_MESSAGE_TEMPLATE, exception.Message);
HandleErrors(menuResponse, exception, 404);
}
else
{
Repository.Delete(toDelete);
menuResponse.StatusCode = 200;
Log.Information("Menu eliminado [{NewName}] por Id:[{Id}].", toDelete.Nombre, toDelete.Id);
}
}
catch (Exception exception)
{
Log.Error(exception, "Error al elimnar el Menu. [{Message}].", exception.Message);
HandleErrors(menuResponse, exception);
}
return(menuResponse);
}
/// <summary>
/// 添加节点
/// </summary>
/// <param name="root">根节点</param>
private void AddNodes(MenuResponse root)
{
var rootNode = ToNode(root);
_result.Add(rootNode);
AddChildren(rootNode);
}
public MenuResponse Execute(UpdateMenuInput input)
{
var menuResponse = new MenuResponse();
try
{
CheckInputValidity(input);
Log.Information("Actualizando Menu por Id: [{Id}] con nuevo nombre: [{NewTitle}]...", input.Id, input.NombreNuevo);
var menuToUpdate = Repository.SingleOrDefault(menu => menu.Id == input.Id);
if (menuToUpdate == null)
{
var exception = new Exception($"No se pudo encontrar el menu con el id: [{input.Id}].");
Log.Error(exception, EXCEPTION_MESSAGE_TEMPLATE, exception.Message);
HandleErrors(menuResponse, exception, 404);
return(menuResponse);
}
menuToUpdate.Nombre = input.NombreNuevo;
menuToUpdate.Base64 = input.Base64Nuevo;
var updatedMenu = Repository.Update(menuToUpdate);
menuResponse.Menu = updatedMenu;
menuResponse.StatusCode = 200;
Log.Information("Actualizado con exito el menu con Id: [{Id}] con nuevo nombre [{NewTitle}].", input.Id, input.NombreNuevo);
}
catch (Exception exception)
{
Log.Error(exception, EXCEPTION_MESSAGE_TEMPLATE, exception.Message);
HandleErrors(menuResponse, exception);
}
return(menuResponse);
}
public MenuResponse Execute(int id)
{
var menuResponse = new MenuResponse();
try
{
Log.Information("Recuperando menu por Id : [{Id}]", id);
var menu = Repository.SingleOrDefault(g => g.Id == id);
if (menu == null)
{
var exception = new Exception($"menu no encontrado por id : [{id}].");
Log.Error(exception, EXCEPTION_MESSAGE_TEMPLATE, exception.Message);
HandleErrors(menuResponse, exception, 404);
}
else
{
//NOTE: Not sure if I want to do something like AutoMapper for this example.
menuResponse.Menu = menu;
menuResponse.StatusCode = 200;
}
}
catch (Exception exception)
{
Log.Error(exception, "Error al obtener menu por Id: [{Id}].", id);
HandleErrors(menuResponse, exception);
}
return(menuResponse);
}
private string GetMenuTree(User user, MenuResponse menuResponse)
{
List <dynamic> menus = GetMultiLanguagesForMenuItems(menuResponse);
List <string> allAuthorizedScreens = GetAllAuthorizedScreensFromUser(user);
List <dynamic> authorizedMenus = menus.Where(m => allAuthorizedScreens.Any(s => m.Id.ToString().Equals(s))).ToList();
return(JsonConvert.SerializeObject(authorizedMenus));
}
/// <summary>
/// 是否根节点
/// </summary>
/// <param name="dto">菜单响应</param>
protected bool IsRoot(MenuResponse dto)
{
if (_menuData.Any(t => t.ParentId.IsEmpty()))
{
return(dto.ParentId.IsEmpty());
}
return(dto.Level == _menuData.Min(t => t.Level));
}
public MenuResponse GetMenuAndApplications(ISurfaceUnitOfWork surfaceUnitOfWork)
{
List <dynamic> menus = GetMenus(surfaceUnitOfWork);
List <Application> applications = applicationHelperService.GetApplications(surfaceUnitOfWork);
MenuResponse menuResponse = new MenuResponse {
Applications = applications == null ? null : JsonConvert.SerializeObject(applications),
Menus = menus == null ? null : JsonConvert.SerializeObject(menus)
};
return(menuResponse);
}
/// <summary>
/// Get menu details
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public MenuResponse GetDetail(MenuRequest request)
{
MenuResponse response = new MenuResponse();
var qry = _unitOfWork.MenuRepository.Query(x => x.ID == request.Data.Id, null);
if (qry.FirstOrDefault() != null)
{
response.Entity = Mapper.Map <Menu, MenuModel>(qry.FirstOrDefault());
}
return(response);
}
public ResultResponse <MenuResponse> GetById(BDHomeFoodContext _context, int id)
{
try
{
ResultResponse <MenuResponse> response = new ResultResponse <MenuResponse>();
var firstresult = _context.Menu.Any(c => c.MenuId == id);
if (firstresult)
{
var result = _context.Menu.FirstOrDefault(c => c.MenuId == id);
MenuResponse menuResponses = new MenuResponse
{
MenuId = result.MenuId,
Name = result.Name,
Description = result.Description,
CollaboratorId = result.CollaboratorId,
Price = result.Price,
State = result.State,
QuantityMenuCurrent = result.QuantityMenuCurrent,
MenuTypeId = result.MenuTypeId,
Photos = _context.Photo.Where(y => y.MenuId == result.MenuId).Select(
y => new PhotoResponse {
PhotoId = y.PhotoId,
UrlPhoto = y.UrlPhoto,
State = y.State,
IsMain = y.IsMain
}
).ToList()
};
response.Data = menuResponses;
response.Error = false;
response.Message = "Datos encontrados";
}
else
{
response.Data = null;
response.Error = true;
response.Message = "No se encontraron datos";
}
return(response);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
private static void SetChildren(List <MenuResponse> menus, MenuResponse parent)
{
var chidren = menus.FindAll(a => a.ParentId == parent.Id);
if (chidren.Count == 0)
{
return;
}
parent.Children = chidren;
foreach (var child in parent.Children)
{
SetChildren(menus, child);
}
}
private static void GetTopMenu(MenuResponse parent, List <MenuResponse> menus, List <MenuResponse> topMenus)
{
var top = menus.Find(a => a.Id == parent.ParentId);
if (top != null)
{
GetTopMenu(top, menus, topMenus);
}
else
{
if (topMenus.Find(a => a.Id == parent.Id) == null)
{
topMenus.Add(parent);
}
}
}
/// <summary>
/// 删除微信自定义菜单
/// </summary>
/// <returns></returns>
public ResultModel DeleteMenu()
{
var response = new MenuResponse();
try
{
response = _weixinService.DeleteMenu().Result;
_result.Message = "删除成功！";
}
catch (Exception e)
{
_result.Status = 0;
_result.Message = response.errmsg;
_logger.LogError($"{_result.Message}{e.Message + e.StackTrace}");
}
return(_result);
}
public static MenuResponse FetchProductMenu()
{
MenuResponse resp = new MenuResponse();
try
{
DataSet MenuDS = new ProductMenu().GetMenu();
resp.Menu = MenuDS;
resp.IsMenuAvailable = true;
}
catch (Exception ex)
{
resp.IsMenuAvailable = false;
Logger.Instance().Log(Fatal.Instance(), ex);
}
return(resp);
}
/// <summary>
/// 转换为树节点
/// </summary>
private MenuInfo ToNode(MenuResponse dto)
{
var result = new MenuInfo {
Id = dto.Id,
Text = dto.Name,
Icon = dto.Icon
};
if (dto.External)
{
result.ExternalLink = dto.Url;
}
else
{
result.Link = dto.Url;
}
return(result);
}
/// <summary>
/// Validate request
/// </summary>
/// <param name="request"></param>
/// <param name="response"></param>
public void Validate(MenuRequest request, out MenuResponse response)
{
response = new MenuResponse();
if (request.Action != null && request.Action.Equals(ClinicEnums.Action.DELETE.ToString()))
{
ValidateForDelete(request, out response);
}
else
{
bool isHavePrivilege = true;
if (request.Data.Name == null || String.IsNullOrWhiteSpace(request.Data.Name))
{
errorFields.Add("Menu Name");
}
if (errorFields.Any())
{
response.Status = false;
response.Message = string.Format(Messages.ValidationErrorFields, String.Join(",", errorFields));
}
if (request.Data.Id == 0)
{
isHavePrivilege = IsHaveAuthorization(ADD_PRIVILEGE_NAME, request.Data.Account.Privileges.PrivilegeIDs);
}
else
{
isHavePrivilege = IsHaveAuthorization(EDIT_PRIVILEGE_NAME, request.Data.Account.Privileges.PrivilegeIDs);
}
if (!isHavePrivilege)
{
response.Status = false;
response.Message = Messages.UnauthorizedAccess;
}
if (response.Status)
{
response = new MenuHandler(_unitOfWork).CreateOrEdit(request);
}
}
}
public static string FetchSerializedProductMenu()
{
int CategoryCount = 0;
int filteredCategoryCount = 0;
Dictionary <string, string> filteredSubCategory = null;
MenuResponse output = FetchProductMenu();
List <object> OutputList = new List <object>();
if (output.IsMenuAvailable)
{
DataView dv = new DataView(output.Menu.Tables[0]);
DataTable DistinctColumn = dv.ToTable(true, "CategoryName");
CategoryCount = DistinctColumn.Rows.Count;
foreach (DataRow dr in DistinctColumn.Rows)
{
DataView dvFiltered = new DataView(output.Menu.Tables[0])
{
RowFilter = "CategoryName = '" + dr[0].ToString() + "'"
};
filteredCategoryCount = dvFiltered.Count;
filteredSubCategory = new Dictionary <string, string>();
foreach (DataRowView drFiltered in dvFiltered)
{
filteredSubCategory.Add(drFiltered["pbsid"].ToString(), drFiltered["ProductName"].ToString());
}
var itemToInsert = new
{
CategoryName = dr[0].ToString(),
SubCategoryCount = filteredCategoryCount,
HasSubCategory = true,
SubCategoryList = filteredSubCategory
};
OutputList.Add(itemToInsert);
}
}
var objmenu = new
{
CategoryCount,
menu = OutputList
};
return(new JavaScriptSerializer().Serialize(objmenu));
}
public MenuResponse getMenuDetails()
{
try
{
MenuResponse SR = new MenuResponse();
SR.Modules = db.CMN_Utl_Modules_GetAll().ToList();
SR.Menus = db.CMN_Utl_Menu_GetAll().ToList();
SR.MenuItems = db.CMN_Utl_MenuItems_GetAll().ToList();
SR.status = 1;
return(SR);
}
catch (Exception Ex)
{
MenuResponse SR = new MenuResponse();
SR.status = 0;
SR.message = "Some Error Occured while Fetching Initial Data";
return(SR);
}
}
/// <summary>
/// Delete validation
/// </summary>
/// <param name="request"></param>
/// <param name="response"></param>
private void ValidateForDelete(MenuRequest request, out MenuResponse response)
{
response = new MenuResponse();
if (request.Action == ClinicEnums.Action.DELETE.ToString())
{
bool isHavePrivilege = IsHaveAuthorization(DELETE_PRIVILEGE_NAME, request.Data.Account.Privileges.PrivilegeIDs);
if (!isHavePrivilege)
{
response.Status = false;
response.Message = Messages.UnauthorizedAccess;
}
}
if (response.Status)
{
response = new MenuHandler(_unitOfWork).RemoveData(request);
}
}
public async Task <IMenuResponse> GetByDate(DateTime date)
{
var menuResponse = new MenuResponse();
try
{
var mySerializer = new XmlSerializer(typeof(Entity.ExternalMenu));
var response = await httpClient.GetStreamAsync($"/menu/{date.ToString("ddMMyy")}");
var result = (Entity.ExternalMenu)mySerializer.Deserialize(response);
return(new MenuResponse()
{
Menu = result, Result = true
});
}
catch (Exception)
{
return(new MenuResponse());
}
}
/// <summary>
/// Remove menu data
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public MenuResponse RemoveData(MenuRequest request)
{
MenuResponse response = new MenuResponse();
try
{
var menu = _unitOfWork.MenuRepository.GetById(request.Data.Id);
if (menu.ID > 0)
{
menu.RowStatus = -1;
menu.ModifiedBy = request.Data.Account.UserCode;
menu.ModifiedDate = DateTime.Now;
_unitOfWork.MenuRepository.Update(menu);
int resultAffected = _unitOfWork.Save();
if (resultAffected > 0)
{
response.Message = string.Format(Messages.ObjectHasBeenRemoved, "Menu", menu.Name, menu.ID);
}
else
{
response.Status = false;
response.Message = string.Format(Messages.RemoveObjectFailed, "Menu");
}
}
else
{
response.Status = false;
response.Message = string.Format(Messages.RemoveObjectFailed, "Menu");
}
}
catch (Exception ex)
{
response.Status = false;
response.Message = Messages.GeneralError;
ErrorLog(ClinicEnums.Module.MASTER_MENU, ClinicEnums.Action.DELETE.ToString(), request.Data.Account, ex);
}
return(response);
}
public MenuResponse Execute(CreateMenuInput input)
{
var menuResponse = new MenuResponse();
try
{
Log.Information("Creando Menu Con nombre [{NewName}]...", input?.Nombre);
byte[] imageBytes = Convert.FromBase64String(input?.Base64);
MenuEntity menuEntity = Mapper.Map <CreateMenuInput, MenuEntity>(input);
menuEntity.FechaCreacion = DateTime.Now;
menuResponse.Menu = Repository.Create(menuEntity);
menuResponse.StatusCode = 200;
Log.Information("Menu creado con el nombre [{NewName}] con el Id: [{Id}]", menuResponse.Menu.Nombre, menuResponse.Menu.Id);
}
catch (Exception exception)
{
Log.Error(exception, "Error al crear el Menu: [{NewName}].", input?.Nombre);
HandleErrors(menuResponse, exception);
}
return(menuResponse);
}
private static void SetFunctions(MenuResponse menu, List <MenuFunctionModel> functions)
{
var children = functions.FindAll(a => a.NavigationId == menu.Id);
if (children.Count > 0)
{
menu.Functions = children.ConvertAll(a => new FunctionSortInfo()
{
Id = a.FunctionId ?? 0, Key = a.FunctionKey, Name = a.FunctionName
});
}
if (menu.Children == null || menu.Children.Count <= 0)
{
return;
}
foreach (var chidMenu in menu.Children)
{
SetFunctions(chidMenu, functions);
}
}
public MenuResponse GetMenuItems(dynamic request)
{
var dataRequest = this.ConvertStupidArgumentToNormalRequset <DataRequest>(request) as DataRequest;
SqlConnection connection = initializeConnection();
var res = new MenuResponse();
var menuItemsList = new List <MenuItem>();
try
{
connection.Open();
SqlCommand cmd = new SqlCommand("MenuItemsSelect", connection);
cmd.CommandType = System.Data.CommandType.StoredProcedure;
var txt = dataRequest.Language == Language.English ? "Text_English" : "Text_Hebrew";
cmd.Parameters.AddWithValue("@lang", txt);
using (SqlDataReader reader = cmd.ExecuteReader())
{
while (reader.Read())
{
double order = reader.IsNUll("Order", -1);
int id = reader.IsNUll("ID", -1);
int imageID = reader.IsNUll("ImageID", -1);
string imageURL = reader.IsNUll("imageURL", "");
string text = reader.IsNUll("Text", "");
bool isDefault = reader.IsNUll("isDefault", false);
string name = reader["Name"].ToString();
var item = new MenuItem(id, order, text, isDefault, name, imageID, imageURL);
menuItemsList.Add(item);
}
}
res.MenuItems = menuItemsList.ToArray();
return(res);
}
finally
{
connection.Close();
}
}
public ResultModel CreateMenu(string button)
{
if (string.IsNullOrEmpty(button))
{
_result.Status = 0;
_result.Message = "参数有误！";
}
else
{
var response = new MenuResponse();
try
{
response = _weixinService.CreateMenu(button).Result;
}
catch (Exception e)
{
_result.Status = 0;
_result.Message = response.errmsg;
_logger.LogError($"{_result.Message}{e.Message + e.StackTrace}");
}
}
return(_result);
}
/// <summary>
/// 获取菜单信息
/// </summary>
/// <returns></returns>
public List <MenuResponse> GetALLMenuList()
{
var res = new List <MenuResponse>();
var whereLambda = PredicateBuilder.True <TblMenu>();
var menuList = LoadEntities(whereLambda);
if (menuList != null && menuList.Count() > 0)
{
//父结点
var parentMenu = menuList.Where(p => p.ParentId == 0);
MenuResponse MenuResponse = null;
parentMenu.ToList().ForEach(p =>
{
MenuResponse = new MenuResponse();
MenuResponse.id = p.Id;
MenuResponse.title = p.Name;
//子结点
var childrenMenu = menuList.Where(u => u.ParentId == p.Id);
if (childrenMenu != null && childrenMenu.Count() > 0)
{
var childrenList = new List <ChildernMenu>();
childrenMenu.ToList().ForEach(u =>
{
childrenList.Add(new ChildernMenu
{
id = u.Id,
title = u.Name
});
});
MenuResponse.children = childrenList;
}
res.Add(MenuResponse);
});
}
return(res);
}
protected void dropdown(string label_value, Texture texture, string menu_ref, DropdownMenuData menu, DryUI parent_window, Rect offset, float btn_width, GUIStyle button_style, GUIStyle menu_style, GUIStyle menu_item_style, MenuResponse callback)
{
if (anchors.ContainsKey(menu_ref))
{
menu.set_attributes(anchors[menu_ref], offset, parent_window, btn_width, menu_style, menu_item_style, callback);
}
section("Button", () => {
label(label_value, "button.text");
GUILayout.Label(texture, width(16f), height(16f));
}, evt => {
if (evt.single_click)
{
open_dropdown(menu);
}
});
track_rect(menu_ref, GUILayoutUtility.GetLastRect(), true);
}
