public void Change(MenuDTO menuDTO)
{
var menu = Map(menuDTO);
db.Menus.Update(menu);
db.Save();
}
/// <summary>
/// Construcción del menú principal
/// </summary>
/// <param name="Roles"></param>
/// <returns></returns>
public MenuDTO ConstruyeListaMenuLj(List <string> Roles)
{
var query = new List <ModuloDTO>();
var busqueda = ConstruyeListaMenu(Roles);
if (busqueda != null && busqueda.Count > 0)
{
query = (from item in busqueda
where item.idPadre == null
select new ModuloDTO
{
href = item.href,
iconUrl = item.iconUrl,
id = item.id,
idPadre = item.idPadre,
text = item.text,
DescripcionModulo = item.DescripcionModulo,
children = ObtenerHijos(item.id, busqueda)
}).ToList();
}
var menu = new MenuDTO {
menu = query
};
return(menu);
}
public void Delete(MenuDTO menuDTO)
{
var menu = Map(menuDTO);
db.Menus.Delete(menu);
db.Save();
}
public void AddMenu(MenuDTO menuDto, long restaurantAdminId, string path)
{
var restaurant = _restaurantService.GetRestaurantByAdminId(restaurantAdminId);
if (restaurant == null)
{
throw new NotFoundException(ErrorCodes.RestaurantNotFound);
}
if (restaurant.IsDeleted)
{
throw new ValidationException(ErrorCodes.RestaurantDeleted);
}
ValidateMenu(menuDto, restaurant.RestaurantId);
var menu = new Menu();
foreach (var menuName in menuDto.MenuNameDictionary)
{
menu.MenuTranslations.Add(new MenuTranslation
{
MenuName = menuName.Value,
Language = menuName.Key.ToLower()
});
}
menu.RestaurantId = restaurant.RestaurantId;
_menuTranslationService.InsertRange(menu.MenuTranslations);
_menuService.Insert(menu);
SaveChanges();
_manageStorage.UploadImage(path + "\\" + "Restaurant-" + menu.RestaurantId + "\\" + "Menu-" + menu.MenuId, menuDto.Image, menu.MenuId.ToString());
}
public void UpdatePermission(MenuDTO menuDTO)
{
//get persisted item
var persisted = _Repository.Get(menuDTO.Id);
if (persisted != null) //if customer exist
{
foreach (var p in menuDTO.Permissions)
{
if (p.Id == Guid.Empty)
{
p.Id = IdentityGenerator.NewSequentialGuid();
p.Created = DateTime.UtcNow;
}
}
foreach (var p in persisted.Permissions.ToArray())
{
// 先删除从表数据
_PermissionRepository.Remove(p);
}
persisted.Permissions = new Collection <Permission>();
foreach (var p in menuDTO.Permissions.Select(x => x.ToModel()))
{
p.Menu = persisted;
persisted.Permissions.Add(p);
}
//commit unit of work
_Repository.UnitOfWork.Commit();
}
}
public MenuDTO GetData(string mnu_code)
{
log.MethodStart();
MenuDTO objModel = new MenuDTO();
using (var trans = _db.Database.BeginTransaction())
{
try
{
var objReturn1 = _db.TCMenus.FirstOrDefault(x => x.mnu_code == mnu_code);
if (objReturn1 != null)
{
objModel = _mapper.Map <MenuDTO>(objReturn1);
}
trans.Commit();
}
catch (Exception ex)
{
// TODO: Handle failure
trans.Rollback();
}
finally
{
trans.Dispose();
}
}
log.MethodFinish();
return(objModel);
}
public void AddMenu(MenuDTO menuDTO)
{
if (menuDTO.Date == null)
{
throw new ValidationException("Дата не установлена", "");
}
if (menuDTO.Date.Date < DateTime.Now.Date)
{
throw new ValidationException("Меню нельзя составлять на прошедшую дату", "");
}
var menus = Database.Menu.GetAll().Where(p => p.ProviderId == menuDTO.ProviderId);
if (menus.Where(p => p.Date.Date == menuDTO.Date).FirstOrDefault() != null)
{
throw new ValidationException("На эту дату меню уже существует", "");
}
Menu menu = new Menu()
{
Date = menuDTO.Date,
Info = menuDTO.Info,
ProviderId = menuDTO.ProviderId
};
Database.Menu.Create(menu);
Database.Save();
}
public IActionResult UpdateMenu(int id, [FromBody] PostMenuDTO menuDTO)
{
_requestLogService.SaveRequest(User.Identity.GetUserId(), "PUT", "api/v1/menus/{id}", "UpdateMenu");
if (!ModelState.IsValid)
{
return(BadRequest("Invalid fields provided, please double check the parameters"));
}
if (menuDTO.RestaurantId.Equals(null))
{
return(BadRequest("Menu is not related any Restaurant"));
}
if (!IsRestaurantUserOrAdmin(menuDTO.RestaurantId))
{
return(BadRequest("Menu can only be updated by admin or by restaurant user"));
}
var m = _menuService.GetMenuById(id);
if (m == null)
{
return(NotFound());
}
if (!(User.IsInRole("premiumUser") && !User.IsInRole("admin")) &&
menuDTO.PromotionId != null && menuDTO.PromotionId != m.PromotionId)
{
return(StatusCode(403, "Promotions to menu can only be added by admin or premium user"));
}
MenuDTO updatedMenu = _menuService.UpdateMenu(id, menuDTO);
return(Ok(updatedMenu));
}
public void EditMenu(MenuDTO menuDTO)
{
if (menuDTO.Date == null)
{
throw new ValidationException("Дата не установлена", "");
}
if (menuDTO.Date.Date < DateTime.Now.Date)
{
throw new ValidationException("Меню нельзя изменять на прошедшую дату", "");
}
var menus = Database.Menu.GetAll().Where(p => p.ProviderId == menuDTO.ProviderId);
var checkDateMenu = menus.Where(p => p.Date.Date == menuDTO.Date).FirstOrDefault();
if (checkDateMenu != null && checkDateMenu.Id != menuDTO.Id)
{
throw new ValidationException("На эту дату меню уже существует", "");
}
Menu menu = Database.Menu.Get(menuDTO.Id);
if (menu == null)
{
throw new ValidationException("Меню не найдено", "");
}
menu.Info = menuDTO.Info;
menu.Date = menuDTO.Date;
Database.Menu.Update(menu);
Database.Save();
}
public ActionResult <MenuDTO> PostMenu(MenuDTO menu)
{
Menu menuToCreate = new Menu(menu.Datum, menu.Omschrijving);
if (menu.Gerechten != null)
{
foreach (var gerecht in menu.Gerechten)
{
menuToCreate.AddGerecht(_gerechtenRepository.GetBy(gerecht.Id), DateTime.Now);
}
}
if (menu.Soepen != null)
{
foreach (var soep in menu.Soepen)
{
menuToCreate.AddSoep(_soepenRepository.GetBy(soep.Id), DateTime.Now);
}
}
if (menu.Desserts != null)
{
foreach (var dessert in menu.Desserts)
{
menuToCreate.AddDessert(_dessertsRepository.GetBy(dessert.Id), DateTime.Now);
}
}
_menusRepository.Add(menuToCreate);
_menusRepository.SaveChanges();
//201 + link naar gecreeerd menu + optioneel het gecreerde menu
return(CreatedAtAction(nameof(GetMenu), new { id = menuToCreate.Id }, MenuDTO.MapMenu(menuToCreate)));
}
public OutPutDTO AddMenus([FromBody] MenuDTO obj)
{
var trans = commonBu.getDbContext().Database.BeginTransaction();
try
{
List <SqlParameter> parameters = new List <SqlParameter>();
string sql = "";
foreach (var MenuID in obj.Selection)
{
string param = "@MenuID" + parameters.Count;
sql += @" INSERT INTO RoleMenu (RoleID, MenuID) Values(@RoleID, " + param + ") ";
parameters.Add(new SqlParameter(param, MenuID));
}
parameters.Add(new SqlParameter("@RoleID", obj.RoleID));
int n = commonBu.getDbContext().Database.ExecuteSqlCommand(sql, parameters.ToArray());
trans.Commit();
return(new OutPutDTO(true, Constants.STATUS_CODE.SUCCESS, Constants.STATUS_MESSAGE.SUCCESS, null));
}
catch (Exception ex)
{
trans.Rollback();
return(new OutPutDTO(false, Constants.STATUS_CODE.EXCEPTION, Constants.STATUS_MESSAGE.EXCEPTION + ex.Message, null));
}
}
public IHttpActionResult GetAll()
{
try
{
List <MenuDTO> MenuDTOs = new List <MenuDTO>();
using (AdminDbContext ctx = new AdminDbContext())
{
List <Menu> menus = ctx.Menus.Where(m => m.MenuId == null).ToList();
foreach (var men in menus)
{
var menuDTO = new MenuDTO();
menuDTO.Menu = men;
menuDTO.Items = ctx.Menus.Where(m => m.MenuId == men.Id).ToList();
MenuDTOs.Add(menuDTO);
}
}
Data data = new Data();
data.MenuDTO = MenuDTOs;
return(Ok(data));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public void UpdateMenu(MenuDTO menuDto, long restaurantAdminId, string path)
{
var menu = _menuService.Find(menuDto.MenuId);
if (menu == null)
{
throw new NotFoundException(ErrorCodes.MenuNotFound);
}
ValidateMenu(menuDto, menu.RestaurantId);
foreach (var menuName in menuDto.MenuNameDictionary)
{
var menuTranslation =
menu.MenuTranslations.FirstOrDefault(x => x.Language.ToLower() == menuName.Key.ToLower());
if (menuTranslation == null)
{
menu.MenuTranslations.Add(new MenuTranslation
{
Language = menuName.Key.ToLower(),
MenuName = menuName.Value
});
}
else
{
menuTranslation.MenuName = menuName.Value;
}
}
_menuService.Update(menu);
SaveChanges();
if (menuDto.IsImageChange)
{
_manageStorage.UploadImage(path + "\\" + "Restaurant-" + menu.RestaurantId + "\\" + "Menu-" + menu.MenuId, menuDto.Image, menu.MenuId.ToString());
}
}
public List <MenuDTO> getMenu()
{
//Test
List <MenuDTO> menuList = new List <MenuDTO>();
MenuDTO Domain_MFG = new MenuDTO();
Domain_MFG.ID = "xxx";
Domain_MFG.Code = "MFG";
Domain_MFG.LanguageID = "lang_MFG";
MenuDTO System_QML = new MenuDTO();
System_QML.ID = "xxx_1";
System_QML.Code = "QML";
Domain_MFG.LanguageID = "lang_QML";
MenuDTO Function_QML_1 = new MenuDTO();
Function_QML_1.ID = "xxx_1_1";
Function_QML_1.Code = "QML_BASE_DATA_MAINTAIN";
Function_QML_1.LanguageID = "lang_menu_aaa";
Function_QML_1.Url = "http://localhost:28937/Forms/TestDataMaintainForm.aspx";
System_QML.SubMenuList.Add(Function_QML_1);
Domain_MFG.SubMenuList.Add(System_QML);
menuList.Add(Domain_MFG);
return(menuList);
}
public ActionResult Edit(int?id)
{
_logger.LogInformation($"{DateTime.Now.ToString()}: Processing request Menu/Edit");
try
{
MenuDTO menuDTO = _menuService.GetMenu(id);
if (menuDTO == null)
{
throw new ValidationException(_sharedLocalizer["MenuNoFind"], "");
}
var provider = new EditMenuViewModel()
{
Id = menuDTO.Id,
Date = menuDTO.Date,
Info = menuDTO.Info,
ProviderId = menuDTO.ProviderId
};
return(View(provider));
}
catch (ValidationException ex)
{
_logger.LogError($"{DateTime.Now.ToString()}: {ex.Property}, {ex.Message}");
return(Content(ex.Message));
}
}
public IActionResult Edit(EditMenuViewModel model)
{
if (ModelState.IsValid)
{
try
{
MenuDTO menuDto = new MenuDTO
{
Id = model.Id,
Date = model.Date,
Info = model.Info,
ProviderId = model.ProviderId
};
_menuService.EditMenu(menuDto);
string currentUserId = this.User.FindFirst(ClaimTypes.NameIdentifier).Value;
_logger.LogInformation($"{DateTime.Now.ToString()}: User {currentUserId} edited menu {model.Id}");
return(RedirectToAction("Index", new { providerId = model.ProviderId }));
}
catch (ValidationException ex)
{
ModelState.AddModelError(ex.Property, ex.Message);
_logger.LogError($"{DateTime.Now.ToString()}: {ex.Property}, {ex.Message}");
}
}
return(View(model));
}
public IActionResult DeleteMenu([FromBody] MenuDTO request)
{
var response = new OperationResponse <ICollection>();
try
{
var result = _lookupService.DeleteMenu(request.Tasks);
if (result.Any(fn => !string.IsNullOrEmpty(fn.Message)))
{
response.State = ResponseState.ValidationError;
response.Data = result.ToList();
return(new JsonResult(response));
}
else
{
response.State = ResponseState.Success;
}
}
catch (Exception exception)
{
response.State = ResponseState.Error;
response.Messages.Add(exception.Message);
_logger.LogError(exception, "Error in DeleteMenu ==>" + exception.StackTrace, request);
}
return(new JsonResult(response));
}
private C1OutPage CreateOutPage(IList<MenuDTO> mainMenu, MenuDTO parentMenu)
{
C1OutPage outPage = new C1OutPage()
{
Name = parentMenu.Id.ToString(),
Text = parentMenu.Name,
Image = GetImage(parentMenu.IconPath),
Tag = parentMenu,
BackgroundImageLayout = System.Windows.Forms.ImageLayout.Tile,
};
C1ToolBar toolBar = new C1ToolBar()
{
Movable = false,
Horizontal = false,
Dock = System.Windows.Forms.DockStyle.Fill,
ButtonLayoutVert = ButtonLayoutEnum.TextBelow,
ButtonLookVert = ButtonLookFlags.TextAndImage,
ButtonAlign = StringAlignment.Center,
};
outPage.Controls.Add(toolBar);
CreateCommandButton(mainMenu, parentMenu, toolBar);
return outPage;
}
public IHttpActionResult Create([FromBody] MenuDTO menu)
{
ThrowIfUserHasNoRole(createRole);
if (menu == null)
{
throw new KairosException("Missing model parameter");
}
if (menu.Menu_PK != 0)
{
throw new KairosException("Post method is not allowed because the requested primary key is must be '0' (zero) .");
}
using (var menuCreateHandler = new MenuCreateHandler(Db, ActiveUser, new MenuValidator(), new MenuFactory(Db, ActiveUser), new MenuQuery(Db), AccessControl))
{
using (var transaction = new TransactionScope())
{
var saveResult = menuCreateHandler.Save(menuDTO: menu, dateStamp: DateTime.Now);
transaction.Complete();
if (saveResult.Success)
{
return(Ok(new SuccessResponse(saveResult.Model, saveResult.Message)));
}
return(Ok(new ErrorResponse(ServiceStatusCode.ValidationError, saveResult.ValidationResult, saveResult.Message)));
}
}
}
public IList <MenuDTO> GetTestSystemMenu()
{
IList <MenuDTO> lLstObjResult = new List <MenuDTO>();
IList <Module> lLstObjModules = GetSortedModulesList();
IList <Section> lLstObjSections = GetSortedSectionsList();
foreach (Module lObjModule in lLstObjModules)
{
MenuDTO lObjMenu = new MenuDTO()
{
Name = lObjModule.Name,
Path = lObjModule.Path,
Children = new List <MenuDTO>()
};
foreach (Section lObjSection in lLstObjSections.Where(x => x.ModuleId == lObjModule.Id))
{
lObjMenu.Children.Add(new MenuDTO()
{
Name = lObjSection.Name,
Path = lObjSection.Path,
Children = new List <MenuDTO>()
});
}
lLstObjResult.Add(lObjMenu);
}
return(lLstObjResult);
}
public HomeViewModel Index()
{
var homeViewModel = new HomeViewModel();
var aa = countryService.Get(1);
var persons = personService.GetNameLike("tuğ");
var menu = new MenuDTO();
menu.ApplicationCode = "code 1";
menu.LinkName = "link 1";
//menuService.Add(menu);
//var menus = menuService.GetAll();
//menuService.Delete(menus.First());
var tempPerson = new PersonDTO();
tempPerson.FirstName = "ali";
tempPerson.LastName = "veli";
tempPerson.Country = countryService.GetFiltered(a => a.Name == "Turkey").First();
//personService.Add(tempPerson);
var person = personService.GetFiltered(a => a.FirstName == "Tuğrul", b => b.Country).FirstOrDefault();
//person.FirstName = "Tuğrul";
//person.Country = countryService.GetFiltered(a => a.ID == 2).First();
//personService.Update(person);
homeViewModel.FirstName = person.FirstName;
homeViewModel.LastName = person.LastName;
homeViewModel.Countries = countryService.GetAll();
return homeViewModel;
}
public ActionResult EditMenu(MenuDTO menu, Guid?module, Guid?parent)
{
return(HttpHandleExtensions.AjaxCallGetResult(() =>
{
menu.Permissions = new Collection <PermissionDTO>();
if (module.HasValue)
{
menu.Module = _moduleService.FindBy(module.Value);
}
if (parent.HasValue)
{
menu.Parent = _menuService.FindBy(parent.Value);
}
if (menu.Id == Guid.Empty)
{
_menuService.Add(menu);
this.JsMessage = MessagesResources.Add_Success;
}
else
{
_menuService.Update(menu);
this.JsMessage = MessagesResources.Update_Success;
}
base.ClearCacheMenus();
// 更新所有登陆用户缓存，以更新菜单信息
AuthorizeManager.ClearAllCache();
return Json(new AjaxResponse
{
Succeeded = true,
RedirectUrl = Url.Action("Index")
});
}));
}
public async Task <ActionResult> Edit([Bind(Include = "MenuID,Text,Link,DisplayOrder,Target,Status,MenuTypeID,MenuParentID,Icon,Properti")] MenuDTO menu)
{
try
{
if (ModelState.IsValid)
{
var response = await client.PutAsJsonAsync("api/Menus/menuID=" + menu.MenuID, menu);
if (response.IsSuccessStatusCode)
{
return(RedirectToAction("Index"));
}
else
{
ModelState.AddModelError(string.Empty, "Error");
}
return(RedirectToAction("Index"));
}
}
catch (Exception ex)
{
ModelState.AddModelError("", "Error: " + ex.ToString());
}
return(View(menu));
}
public IActionResult Edit(int key = 0)
{
if (key <= 0)
{
return(BadRequest(String.Format(_localizer[ErrorConstants.ARGUMENT_IS_MISSING], "Target menu")));
}
MenuDTO menu = _mnuService.FindByKey(key);
if (menu == null)
{
return(BadRequest(String.Format(_localizer[ErrorConstants.MENU_NOT_EXISTED])));
}
UpdateMenuViewModel model = new UpdateMenuViewModel(_mnuService.GetAll().ToMenuViewModels(true));
model.Key = menu.Key;
model.Name = menu.Name;
model.Url = menu.Url;
model.Order = menu.Order;
model.ParentKey = menu.ParentMenuKey;
model.Visible = menu.Visible;
return(ViewComponent("EditMenu", model));
}
private void validateCreateUpdateMenu(MenuDTO dto, Menu entity)
{
base.HandleValidation(msg =>
{
if (entity is null)
{
msg.Add("Menu cannot found");
}
else if (entity.Status != MenuStatus.Draft)
{
msg.Add("Only draft menu can be edited");
}
if (dto is null)
{
msg.Add("Dto cannot found");
}
else
{
if (string.IsNullOrEmpty(dto.Name))
{
msg.Add("A menu name is required");
}
}
});
}
public void Update(MenuDTO menuDTO)
{
//get persisted item
var persisted = _Repository.Get(menuDTO.Id);
if (persisted != null) //if customer exist
{
var current = menuDTO.ToModel();
current.Created = persisted.Created; //不修改创建时间
if (current.Name.IsNullOrBlank())
{
throw new DataExistsException(UserSystemResource.Common_Name_Empty);
}
if (_Repository.Exists(current))
{
throw new DataExistsException(UserSystemResource.Menu_Exists);
}
//Merge changes
_Repository.Merge(persisted, current);
//commit unit of work
_Repository.UnitOfWork.Commit();
}
else
{
// Not Exists
}
}
public IActionResult Index([FromForm] MenuAddEditPostModel model)
{
if (!ModelState.IsValid)
{
return(Json(new AjaxResult()
{
Status = "error", ErrorMsg = MvcHelper.GetValidMsg(ModelState)
}));
}
var dto = new MenuDTO()
{
Id = model.Id,
DisplayName = model.DisplayName,
Name = model.Name,
IconUrl = model.IconUrl,
LinkUrl = model.LinkUrl,
ParentId = model.ParentId,
Permission = model.Permission,
Sort = model.Sort
};
var id = _menuService.AddOrEdit(dto);
if (id <= 0)
{
return(Json(new AjaxResult()
{
Status = "error", ErrorMsg = "已存在相同的菜单名称"
}));
}
return(Json(new AjaxResult()
{
Status = "ok"
}));
}
private void Save()
{
MenuDTO menu = new MenuDTO();
menu.Categories.AddRange(Categories);
RaiseMenuChangedEvent(menu);
}
private MenuDTO ToMenuDTO(DishType dishTypesWithDishes)
{
MenuDTO menu = new MenuDTO();
menu.Title = dishTypesWithDishes.Title;
menu.Dishes = dishTypesWithDishes.Dishes.Select(ToMenuDishDTO).ToList();
return(menu);
}
public async Task <MenuDTO> GetDataAsync(string mnu_Id)
{
MenuDTO menu = new MenuDTO();
menu = await _apiHelper.GetDataByIdAsync <MenuDTO>("menu_api/Get_Data", mnu_Id);
return(menu);
}
/// <summary>
///
/// </summary>
/// <param name="data"></param>
/// <returns></returns>
public static MenuDTO JsonToList(string data)
{
using (stream = new MemoryStream(Encoding.UTF8.GetBytes(data)))
{
menu = jsonSerializer.ReadObject(stream) as MenuDTO;
}
return(menu);
}
public void Deactivate(MenuDTO menuDTO)
{
menuDTO.IsActive = false;
var menu = Map(menuDTO);
db.Menus.Update(menu);
db.Save();
}
public void BuildOutBar(IList<MenuDTO> mainMenu, MenuDTO module)
{
this.outBar.Pages.Clear();
this.outBar.PageTitleHeight = 30;
mainMenu.Where(x => x.Parent == module && x.MenuType == MenuType.Menu)
.OrderBy(x => x.OrderId)
.ToList()
.ForEach(x =>
{
C1OutPage c1OutPage = CreateOutPage(mainMenu, x);
this.outBar.Pages.Add(c1OutPage);
});
}
private void CreateCommandButton(IList<MenuDTO> mainMenu, MenuDTO parentMenu, C1ToolBar c1ToolBar)
{
mainMenu.Where(x => x.Parent == parentMenu && x.MenuType == MenuType.Form)
.Distinct()
.OrderBy(x => x.OrderId)
.ToList()
.ForEach(x =>
{
string commandButtonId = x.Id.ToString();
C1Command commandButton = new C1Command()
{
Name = commandButtonId,
Text = string.IsNullOrWhiteSpace(x.Name) ? commandButtonId : x.Name,
Image = GetImage(x.IconPath),
UserData = x,
};
commandButton.Click += new ClickEventHandler(this.commandButton_ClickEventHandler);
c1ToolBar.CommandLinks.Add(new C1CommandLink(commandButton));
});
}
private void OpenWindow(MenuDTO menuItem)
{
try
{
if (menuItem == null)
throw new ArgumentNullException("menuItem");
if (menuItem.AssociatedForm == null)
throw new Exception(string.Format("No form definition was found for menu id '{0}'", menuItem.Id));
string fullFormName = menuItem.AssociatedForm.Name;
foreach (C1DockingTabPage tabPage in this.c1DockingTab.TabPages)
{
object tag = tabPage.Tag;
if (tag != null && tag == menuItem)
{
this.c1DockingTab.SelectedTab = tabPage;
return;
}
}
if (this.MdiChildren.Length > 10)
throw new Exception("Can not open window more than 10");
OpenMDIForm(menuItem);
}
catch(Exception ex)
{
//string msg = string.Empty;
//string menuFullPath = menuItem.MenuName;
//this.GetMenuFullPath(menuDataTable, menuItem, ref menuFullPath);
//string actionType = WalkershopContext.GetMessage(MessageKeys.CLICK_MENU_ACTION);
//string messageText = WalkershopContext.GetMessage(MessageKeys.MESSAGE_TEXT);
//string actionText = WalkershopContext.GetMessage(MessageKeys.ACTION_TEXT);
//msg += string.Format("{0}: {1} [{2}]", actionText, actionType, menuFullPath);
//msg += "\n";
//msg += string.Format("{0}: {1}", messageText, e.Message);
logger.Error(ex);
MessageBox.Show(ex.Message, menuItem.Name, MessageBoxButtons.OK, MessageBoxIcon.Information);
}
}
private void OpenMDIForm(MenuDTO menuItem)
{
if (menuItem.AssociatedForm.Assembly == null)
throw new Exception(string.Format("No assembly was found with associated form '{0}'", menuItem.AssociatedForm.Name));
string assemblyFile = menuItem.AssociatedForm.Assembly.Name;
string fullFormName = menuItem.AssociatedForm.Name;
if (!System.IO.File.Exists(assemblyFile))
throw new System.IO.FileNotFoundException(string.Format("Assembly file '{0}' not found.", assemblyFile));
Assembly assembly = Assembly.LoadFrom(assemblyFile);
if (assembly == null)
throw new Exception("Loading assembly file error");
Type formType = assembly.GetType(fullFormName);
if (formType == null)
throw new Exception(string.Format("Can not get form type in assembly file '{0}' with form name '{1}'", assemblyFile, fullFormName));
object obj = Activator.CreateInstance(formType);
C1DockingTabPage tabPage = new C1DockingTabPage()
{
Text = menuItem.Name,
Tag = menuItem
};
c1DockingTab.TabPages.Add(tabPage);
Form childForm = (obj as Form);
childForm.TopLevel = false;
childForm.Parent = tabPage;
childForm.Tag = menuItem;
childForm.Text = menuItem.Name;
childForm.FormBorderStyle = System.Windows.Forms.FormBorderStyle.None;
childForm.Dock = DockStyle.Fill;
tabPage.Controls.Add(childForm);
c1DockingTab.SelectedTab = tabPage;
SetWindowTheme(c1DockingTab);
childForm.Show();
}
