protected void BindData()
{
RoleItem userObj = new RoleItem();
PagerNavication.RecordsCount = DataBase.HEntityCommon.HEntity(userObj).EntityCount();
RoleItem[] al = RoleItem.List("", "", PagerNavication.PageIndex, PagerNavication.PageSize);
rptItems.DataSource = al;
rptItems.DataBind();
}
protected void btnSave_ServerClick(object sender, EventArgs e)
{
string strRoleName = txt_RoleName.Value.Trim();
string strRemark = txt_Remark.Value.Trim();
RoleItem existObj = new RoleItem();
existObj.RoleName = strRoleName;
int nExist = DataBase.HEntityCommon.HEntity(existObj).EntityCount();
if (nExist > 1)
{
PageUtil.PageAlert(this.Page, string.Format("RoleItem(“{0}”) exist mutil records！", strRoleName));
return;
}
if (nExist == 1)
{
PageUtil.PageAlert(this.Page, string.Format("角色“{0}”已存在！", strRoleName));
return;
}
RoleItem addItem = new RoleItem();
addItem.RoleName = strRoleName;
addItem.Remark = strRemark;
DataBase.HEntityCommon.HEntity(addItem).EntitySave();
PageUtil.PageAlert(this.Page, "保存成功！");
}
public bool UserInRole(UserItem user, RoleItem role)
{
var list = _roleRepository.GetListByUser(user);
return(list.Exists(x => x.Code == "Admin" || x.Id == role.Id));
}
public int AddRoleItem(RoleItem item)
{
throw new NotImplementedException();
}
/// <summary> 获取奖励字符串 </summary>
public string GetRewardString(string maxc, string maxr, string mc, string mr, string reward, RoleItem role)
{
role = role.CloneEntity();
if (TaskCommon.CheckRewardCondition(maxc, role))
{
return(maxr);
}
return(TaskCommon.CheckRewardCondition(mc, role)
? mr : reward);
}
public bool UpdateRoleItem(RoleItem item)
{
throw new NotImplementedException();
}
/// <summary>
/// 技能验证
/// </summary>
/// <param name="basetask"></param>
/// <param name="role"></param>
/// <returns></returns>
private bool CheckSkill(BaseTaskVocation basetask, RoleItem role)
{
try
{
if (basetask.skillCondition == "")
{
return(true);
}
var sc = basetask.skillCondition.Split('_');
var type = Convert.ToInt32(sc[0]); //0：技能 1属性
var type1 = Convert.ToInt32(sc[1]); //技能或者属性类型
var value = Convert.ToInt32(sc[2]); //技能或者属性值
if (type == 0)
{
#region 技能
switch (type1)
{
case (int)LifeSkillType.ARTILLERY:
return(role.LifeSkill.sub_artillery_level >= value);
case (int)LifeSkillType.ARCHER:
return(role.LifeSkill.sub_archer_level >= value);
case (int)LifeSkillType.ASHIGARU:
return(role.LifeSkill.sub_ashigaru_level >= value);
case (int)LifeSkillType.BUILD:
return(role.LifeSkill.sub_build_level >= value);
case (int)LifeSkillType.CALCULATE:
return(role.LifeSkill.sub_calculate_level >= value);
case (int)LifeSkillType.CRAFT:
return(role.LifeSkill.sub_craft_level >= value);
case (int)LifeSkillType.ELOQUENCE:
return(role.LifeSkill.sub_eloquence_level >= value);
case (int)LifeSkillType.EQUESTRIAN:
return(role.LifeSkill.sub_equestrian_level >= value);
case (int)LifeSkillType.ETIQUETTE:
return(role.LifeSkill.sub_etiquette_level >= value);
case (int)LifeSkillType.MARTIAL:
return(role.LifeSkill.sub_martial_level >= value);
case (int)LifeSkillType.MEDICAL:
return(role.LifeSkill.sub_medical_level >= value);
case (int)LifeSkillType.MINE:
return(role.LifeSkill.sub_mine_level >= value);
case (int)LifeSkillType.NINJITSU:
return(role.LifeSkill.sub_ninjitsu_level >= value);
case (int)LifeSkillType.RECLAIMED:
return(role.LifeSkill.sub_reclaimed_level >= value);
case (int)LifeSkillType.TACTICAL:
return(role.LifeSkill.sub_tactical_level >= value);
case (int)LifeSkillType.TEA:
return(role.LifeSkill.sub_tea_level >= value);
}
#endregion
}
if (type != 1)
{
return(true);
}
#region 属性
switch (type1)
{
case (int)RoleAttributeType.ROLE_CAPTAIN: return((int)tg_role.GetSingleTotal(RoleAttributeType.ROLE_CAPTAIN, role.Kind) >= value);
case (int)RoleAttributeType.ROLE_FORCE: return((int)tg_role.GetSingleTotal(RoleAttributeType.ROLE_FORCE, role.Kind) >= value);
case (int)RoleAttributeType.ROLE_BRAINS: return((int)tg_role.GetSingleTotal(RoleAttributeType.ROLE_BRAINS, role.Kind) >= value);
case (int)RoleAttributeType.ROLE_CHARM: return((int)tg_role.GetSingleTotal(RoleAttributeType.ROLE_CHARM, role.Kind) >= value);
case (int)RoleAttributeType.ROLE_GOVERN: return((int)tg_role.GetSingleTotal(RoleAttributeType.ROLE_GOVERN, role.Kind) >= value);
}
#endregion
return(true);
}
catch (Exception ex)
{
XTrace.WriteException(ex);
return(false);
}
}
public static bool UserInRole(UserItem user, RoleItem role)
{
return(_accessService.UserInRole(user, role));
}
/// <summary>是否已在学习其他技能 </summary>
public int SkillStudying(RoleItem roleitem)
{
#region
if (roleitem.LifeSkill.sub_archer_state == (int)SkillLearnType.STUDYING)
{
return(roleitem.LifeSkill.sub_archer);
}
if (roleitem.LifeSkill.sub_artillery_state == (int)SkillLearnType.STUDYING)
{
return(roleitem.LifeSkill.sub_artillery);
}
if (roleitem.LifeSkill.sub_ashigaru_state == (int)SkillLearnType.STUDYING)
{
return(roleitem.LifeSkill.sub_ashigaru);
}
if (roleitem.LifeSkill.sub_build_state == (int)SkillLearnType.STUDYING)
{
return(roleitem.LifeSkill.sub_build);
}
if (roleitem.LifeSkill.sub_calculate_state == (int)SkillLearnType.STUDYING)
{
return(roleitem.LifeSkill.sub_calculate);
}
if (roleitem.LifeSkill.sub_craft_state == (int)SkillLearnType.STUDYING)
{
return(roleitem.LifeSkill.sub_craft);
}
if (roleitem.LifeSkill.sub_eloquence_state == (int)SkillLearnType.STUDYING)
{
return(roleitem.LifeSkill.sub_eloquence);
}
if (roleitem.LifeSkill.sub_equestrian_state == (int)SkillLearnType.STUDYING)
{
return(roleitem.LifeSkill.sub_equestrian);
}
if (roleitem.LifeSkill.sub_etiquette_state == (int)SkillLearnType.STUDYING)
{
return(roleitem.LifeSkill.sub_etiquette);
}
if (roleitem.LifeSkill.sub_martial_state == (int)SkillLearnType.STUDYING)
{
return(roleitem.LifeSkill.sub_martial);
}
if (roleitem.LifeSkill.sub_medical_state == (int)SkillLearnType.STUDYING)
{
return(roleitem.LifeSkill.sub_medical);
}
if (roleitem.LifeSkill.sub_mine_state == (int)SkillLearnType.STUDYING)
{
return(roleitem.LifeSkill.sub_mine);
}
if (roleitem.LifeSkill.sub_ninjitsu_state == (int)SkillLearnType.STUDYING)
{
return(roleitem.LifeSkill.sub_ninjitsu);
}
if (roleitem.LifeSkill.sub_reclaimed_state == (int)SkillLearnType.STUDYING)
{
return(roleitem.LifeSkill.sub_reclaimed);
}
if (roleitem.LifeSkill.sub_tactical_state == (int)SkillLearnType.STUDYING)
{
return(roleitem.LifeSkill.sub_tactical);
}
if (roleitem.LifeSkill.sub_tea_state == (int)SkillLearnType.STUDYING)
{
return(roleitem.LifeSkill.sub_tea);
}
return(0);
#endregion
}
public ActionResult Update(RoleItem role)
{
Access.CheckAccess("Role.Updater");
_roleService.Update(role);
return(RedirectToAction("Index", new { id = role.Id }));
}
public ActionResult Create(RoleItem role)
{
Access.CheckAccess("Role.Creator");
return(RedirectToAction("Index", new { id = _roleService.Create(role) }));
}
public ActionResult Info()
{
UserInfo info = new UserInfo();
info.id = Guid.NewGuid();
info.name = "天野远子";
info.username = "******";
info.password = "";
info.avatar = "/avatar2.jpg";
info.status = 1;
info.telephone = "";
info.lastLoginIp = "27.154.74.117";
info.lastLoginTime = 1534837621348;
info.creatorId = "admin";
info.createTime = 1497160610259;
info.merchantCode = "TLif2btpzg079h15bk";
info.deleted = 0;
info.roleId = "admin";
RoleItem role = new RoleItem();
role.id = "admin";
role.name = "管理员";
role.describe = "拥有所有权限";
role.creatorId = "system";
role.createTime = 1497160610259;
role.deleted = 0;
List <Item> item = new List <Item>();
item.Add(new Item {
action = "add", describe = "新增", defaultCheck = false
});
item.Add(new Item {
action = "import", describe = "导入", defaultCheck = false
});
item.Add(new Item {
action = "get", describe = "详情", defaultCheck = false
});
item.Add(new Item {
action = "update", describe = "修改", defaultCheck = false
});
item.Add(new Item {
action = "delete", describe = "删除", defaultCheck = false
});
item.Add(new Item {
action = "export", describe = "导出", defaultCheck = false
});
List <Item> item1 = new List <Item>();
item1.Add(new Item {
action = "add", describe = "新增", defaultCheck = false
});
item1.Add(new Item {
action = "import", describe = "导入", defaultCheck = false
});
item1.Add(new Item {
action = "get", describe = "详情", defaultCheck = false
});
item1.Add(new Item {
action = "update", describe = "修改", defaultCheck = false
});
item1.Add(new Item {
action = "delete", describe = "删除", defaultCheck = false
});
item1.Add(new Item {
action = "export", describe = "导出", defaultCheck = false
});
List <permissions> per = new List <permissions>();
per.Add(new permissions {
roleId = "admin", permissionId = "dashboard", permissionName = "仪表盘", actions = item, actionEntitySet = item1
});
per.Add(new permissions {
roleId = "admin", permissionId = "user", permissionName = "用户管理", actions = item, actionEntitySet = item1
});
per.Add(new permissions {
roleId = "admin", permissionId = "support", permissionName = "超级模块", actions = item, actionEntitySet = item1
});
role.permissions = per;
info.role = role;
return(new JsonResult(new MyJsonResult {
Code = "200", Result = info
}));
}
public bool UserInRole(UserItem user, RoleItem role)
{
var list = _roleRepository.GetListByUser(user);
return(list.Exists(x => x.Code == "Admin" || role.Code.StartsWith(x.Code)));
}
private void AddChildItem(RoleItem parent, RoleItem item)
{
Dispatcher.Invoke(new Action(() => parent.AddChild(item)));
}
private void ClearChildren(RoleItem parentItem)
{
Dispatcher.Invoke(new Action(() => parentItem.Children.Clear()));
}
/// <summary> 验证奖励标准 </summary>
public bool CheckRewardCondition(string rewardcondition, RoleItem roleitem)
{
var list = rewardcondition.Split('|').ToList();
foreach (var item in list)
{
var type = Convert.ToInt32(item.Split('_')[0]);
var type1 = Convert.ToInt32(item.Split('_')[1]);
var value = Convert.ToInt32(item.Split('_')[2]);
if (type == 0)
{
switch (type1)
{
#region 技能验证
case (int)LifeSkillType.ARTILLERY: //铁炮
{
if (roleitem.LifeSkill.sub_artillery_level < value)
{
return(false);
}
}
break;
case (int)LifeSkillType.ARCHER: //弓术
{
if (roleitem.LifeSkill.sub_archer_level < value)
{
return(false);
}
}
break;
case (int)LifeSkillType.ASHIGARU: //足轻
{
if (roleitem.LifeSkill.sub_ashigaru_level < value)
{
return(false);
}
}
break;
case (int)LifeSkillType.BUILD: //建筑
{
if (roleitem.LifeSkill.sub_build_level < value)
{
return(false);
}
}
break;
case (int)LifeSkillType.CALCULATE: //算术
{
if (roleitem.LifeSkill.sub_calculate_level < value)
{
return(false);
}
}
break;
case (int)LifeSkillType.CRAFT: //艺术
{
if (roleitem.LifeSkill.sub_craft_level < value)
{
return(false);
}
}
break;
case (int)LifeSkillType.ELOQUENCE: //辩才
{
if (roleitem.LifeSkill.sub_eloquence_level < value)
{
return(false);
}
}
break;
case (int)LifeSkillType.EQUESTRIAN: //马术
{
if (roleitem.LifeSkill.sub_equestrian_level < value)
{
return(false);
}
}
break;
case (int)LifeSkillType.ETIQUETTE: //礼法
{
if (roleitem.LifeSkill.sub_etiquette_level < value)
{
return(false);
}
}
break;
case (int)LifeSkillType.MARTIAL: //武艺
{
if (roleitem.LifeSkill.sub_martial_level < value)
{
return(false);
}
}
break;
case (int)LifeSkillType.MEDICAL: //医术
{
if (roleitem.LifeSkill.sub_medical_level < value)
{
return(false);
}
}
break;
case (int)LifeSkillType.MINE: //矿山
{
if (roleitem.LifeSkill.sub_mine_level < value)
{
return(false);
}
}
break;
case (int)LifeSkillType.NINJITSU: //忍术
{
if (roleitem.LifeSkill.sub_ninjitsu_level < value)
{
return(false);
}
}
break;
case (int)LifeSkillType.RECLAIMED: //开垦
{
if (roleitem.LifeSkill.sub_reclaimed_level < value)
{
return(false);
}
}
break;
case (int)LifeSkillType.TACTICAL: //军学
{
if (roleitem.LifeSkill.sub_tactical_level < value)
{
return(false);
}
}
break;
case (int)LifeSkillType.TEA: //茶道
{
if (roleitem.LifeSkill.sub_tea_level < value)
{
return(false);
}
}
break;
#endregion
}
}
if (type != 1)
{
continue;
}
#region 属性验证
switch (type1)
{
case (int)RoleAttributeType.ROLE_CAPTAIN: //统帅
{
if (tg_role.GetSingleTotal(RoleAttributeType.ROLE_CAPTAIN, roleitem.Kind) < value)
{
return(false);
}
}
break;
case (int)RoleAttributeType.ROLE_FORCE: //武力
{
if (tg_role.GetSingleTotal(RoleAttributeType.ROLE_FORCE, roleitem.Kind) < value)
{
return(false);
}
}
break;
case (int)RoleAttributeType.ROLE_BRAINS: //智谋
{
if (tg_role.GetSingleTotal(RoleAttributeType.ROLE_BRAINS, roleitem.Kind) < value)
{
return(false);
}
}
break;
case (int)RoleAttributeType.ROLE_CHARM: //魅力
{
if (tg_role.GetSingleTotal(RoleAttributeType.ROLE_CHARM, roleitem.Kind) < value)
{
return(false);
}
}
break;
case (int)RoleAttributeType.ROLE_GOVERN: //政务
{
if (tg_role.GetSingleTotal(RoleAttributeType.ROLE_GOVERN, roleitem.Kind) < value)
{
return(false);
}
}
break;
}
#endregion
}
return(true);
}
/// <summary>获得等级或属性值</summary>
public int GetLifeSkillType(RoleItem role, string basedata)
{
var type1 = Convert.ToInt32(basedata.Split('_')[0]); //0：技能 1：属性
var type2 = Convert.ToInt32(basedata.Split('_')[1]);
if (type1 == 0)
{
#region 技能
switch (type2)
{
case (int)LifeSkillType.ARTILLERY: return(role.LifeSkill.sub_artillery_level);
case (int)LifeSkillType.ARCHER: return(role.LifeSkill.sub_archer_level);
case (int)LifeSkillType.ASHIGARU: return(role.LifeSkill.sub_ashigaru_level);
case (int)LifeSkillType.BUILD: return(role.LifeSkill.sub_build_level);
case (int)LifeSkillType.CALCULATE: return(role.LifeSkill.sub_calculate_level);
case (int)LifeSkillType.CRAFT: return(role.LifeSkill.sub_craft_level);
case (int)LifeSkillType.ELOQUENCE: return(role.LifeSkill.sub_eloquence_level);
case (int)LifeSkillType.EQUESTRIAN: return(role.LifeSkill.sub_equestrian_level);
case (int)LifeSkillType.ETIQUETTE: return(role.LifeSkill.sub_etiquette_level);
case (int)LifeSkillType.MARTIAL: return(role.LifeSkill.sub_martial_level);
case (int)LifeSkillType.MEDICAL: return(role.LifeSkill.sub_medical_level);
case (int)LifeSkillType.MINE: return(role.LifeSkill.sub_mine_level);
case (int)LifeSkillType.NINJITSU: return(role.LifeSkill.sub_ninjitsu_level);
case (int)LifeSkillType.RECLAIMED: return(role.LifeSkill.sub_reclaimed_level);
case (int)LifeSkillType.TACTICAL: return(role.LifeSkill.sub_tactical_level);
case (int)LifeSkillType.TEA: return(role.LifeSkill.sub_tea_level);
}
#endregion
}
if (type1 != 1)
{
return(0);
}
#region 属性
switch (type2)
{
case (int)RoleAttributeType.ROLE_CAPTAIN: return((int)tg_role.GetSingleTotal(RoleAttributeType.ROLE_CAPTAIN, role.Kind));
case (int)RoleAttributeType.ROLE_FORCE: return((int)tg_role.GetSingleTotal(RoleAttributeType.ROLE_FORCE, role.Kind));
case (int)RoleAttributeType.ROLE_BRAINS: return((int)tg_role.GetSingleTotal(RoleAttributeType.ROLE_BRAINS, role.Kind));
case (int)RoleAttributeType.ROLE_CHARM: return((int)tg_role.GetSingleTotal(RoleAttributeType.ROLE_CHARM, role.Kind));
case (int)RoleAttributeType.ROLE_GOVERN: return((int)tg_role.GetSingleTotal(RoleAttributeType.ROLE_GOVERN, role.Kind));
}
#endregion
return(0);
}
/// <summary>
/// Проверяет эквивалентны ли две роли.
/// </summary>
/// <param name="first_role">Первая роль.</param>
/// <param name="second_role">Вторая роль.</param>
private void AreEqualRoles(RoleItem first_role, RoleItem second_role)
{
Assert.AreEqual(first_role.Id, second_role.Id);
Assert.AreEqual(first_role.Code, second_role.Code);
Assert.AreEqual(first_role.Mem, second_role.Mem);
}
public static void CheckRole(RoleItem role)
{
_accessService.CheckRole(role);
}
private static DataRow FillRoleItemRow(DataRow row, RoleItem ri, bool exclude)
{
row[Constants.Properties.RoleItem] = ri.Name;
row[Constants.Properties.RoleExtraData] = ri.ExtraData;
row[Constants.Properties.RoleExclude] = exclude;
if (ri is GroupItem)
{
row[Constants.Properties.RoleItemType] = Constants.RoleItemType.Group;
}
else if (ri is UserItem)
{
row[Constants.Properties.RoleItemType] = Constants.RoleItemType.User;
}
else if (ri is SmartObjectItem)
{
row[Constants.Properties.RoleItemType] = Constants.RoleItemType.SmartObject;
}
else
{
row[Constants.Properties.RoleItemType] = Constants.RoleItemType.Unknown;
}
return row;
}
public int AddRoleItem(RoleItem item)
{
_roleItems.Add(item.Id, item.Clone());
return(item.Id);
}
/// <summary> 生活技能学习推送</summary>
public void CommandStart(TGGSession session, RoleItem role)
{
# if DEBUG
private static DataRow FillRoleItemRow(DataRow row, RoleItem ri, bool exclude)
{
row[Constants.SOProperties.Role.RoleItem] = ri.Name;
row[Constants.SOProperties.Role.RoleExclude] = exclude;
if (ri is GroupItem)
{
row[Constants.SOProperties.Role.RoleItemType] = "Group";
}
else if (ri is UserItem)
{
row[Constants.SOProperties.Role.RoleItemType] = "User" ;
}
else if (ri is SmartObjectItem)
{
row[Constants.SOProperties.Role.RoleItemType] = "SmartObject";
}
else
{
row[Constants.SOProperties.Role.RoleItemType] = "Unknown";
}
return row;
}
public List <Role> list_roles(string aa)
{
aa = "role1";
db = new DbContext();
var tablerole = db.RoleDb.GetList(it => it.rolecode == aa);
List <Role> ListRole = new List <Role>();
Role RoleData = new Role();
RoleItem RoleItemData = new RoleItem();
for (int i = 0; i < tablerole.Count; i++)
{
if (tablerole[i].operation == "select")
{
if (Dic_Data.ContainsKey(1))
{
string[] b = Dic_Data[1];
b = b.Concat(new string[] { tablerole[i].tables }).ToArray();
Dic_Data.Add(1, b);
}
else
{
string[] b = { tablerole[i].tables };
Dic_Data.Add(1, b);
}
if (Dic_Data.ContainsKey(2))
{
string[] c = Dic_Data[2];
c = c.Concat(new string[] { tablerole[i].column }).ToArray();
Dic_Data.Add(2, c);
}
else
{
string[] c = { tablerole[i].column };
Dic_Data.Add(2, c);
}
if (Dic_Data.ContainsKey(3))
{
string[] d = Dic_Data[3];
d = d.Concat(new string[] { tablerole[i].where }).ToArray();
Dic_Data.Add(3, d);
}
else
{
string[] d = { tablerole[i].where };
Dic_Data.Add(3, d);
}
}
else if (tablerole[i].operation == "insert")
{
// RoleItemData.Table = tablerole[i].tables;
if (Dic_Data.ContainsKey(4))
{
string[] b = Dic_Data[4];
b = b.Concat(new string[] { tablerole[i].tables }).ToArray();
Dic_Data.Add(4, b);
}
else
{
string[] b = { tablerole[i].tables };
Dic_Data.Add(4, b);
}
if (Dic_Data.ContainsKey(5))
{
string[] c = Dic_Data[5];
c = c.Concat(new string[] { tablerole[i].column }).ToArray();
Dic_Data.Add(5, c);
}
else
{
string[] c = { tablerole[i].column };
Dic_Data.Add(5, c);
}
if (Dic_Data.ContainsKey(6))
{
if (tablerole[i].where != null)
{
string[] d = Dic_Data[6];
d = d.Concat(new string[] { tablerole[i].where }).ToArray();
Dic_Data.Add(6, d);
}
}
else
{
if (tablerole[i].where != null)
{
string[] d = { tablerole[i].where };
Dic_Data.Add(6, d);
}
}
}
else if (tablerole[i].operation == "updare")
{
// RoleItemData.Table = tablerole[i].tables;
if (Dic_Data.ContainsKey(7))
{
string[] b = Dic_Data[7];
b = b.Concat(new string[] { tablerole[i].tables }).ToArray();
Dic_Data.Add(7, b);
}
else
{
string[] b = { tablerole[i].tables };
Dic_Data.Add(7, b);
}
if (Dic_Data.ContainsKey(8))
{
string[] c = Dic_Data[8];
c = c.Concat(new string[] { tablerole[i].column }).ToArray();
Dic_Data.Add(8, c);
}
else
{
string[] c = { tablerole[i].column };
Dic_Data.Add(8, c);
}
if (Dic_Data.ContainsKey(9))
{
if (tablerole[i].where != null)
{
string[] d = Dic_Data[9];
d = d.Concat(new string[] { tablerole[i].where }).ToArray();
Dic_Data.Add(9, d);
}
}
else
{
if (tablerole[i].where != null)
{
string[] d = { tablerole[i].where };
Dic_Data.Add(9, d);
}
}
}
else if (tablerole[i].operation == "delete")
{
// RoleItemData.Table = tablerole[i].tables;
if (Dic_Data.ContainsKey(10))
{
string[] b = Dic_Data[10];
b = b.Concat(new string[] { tablerole[i].tables }).ToArray();
Dic_Data.Add(10, b);
}
else
{
string[] b = { tablerole[i].tables };
Dic_Data.Add(10, b);
}
if (Dic_Data.ContainsKey(11))
{
string[] c = Dic_Data[11];
c = c.Concat(new string[] { tablerole[i].column }).ToArray();
Dic_Data.Add(11, c);
}
else
{
string[] c = { tablerole[i].column };
Dic_Data.Add(11, c);
}
if (Dic_Data.ContainsKey(12))
{
if (tablerole[i].where != null)
{
string[] d = Dic_Data[12];
d = d.Concat(new string[] { tablerole[i].where }).ToArray();
Dic_Data.Add(12, d);
}
}
else
{
if (tablerole[i].where != null)
{
string[] d = { tablerole[i].where };
Dic_Data.Add(12, d);
}
}
}
}
if (Dic_Data.ContainsKey(1))
{
if (RoleData.Select == null)
{
RoleData.Select = new RoleItem();
RoleData.Select.Table = Dic_Data[1];
}
else
{
RoleData.Select.Table = Dic_Data[1];
}
}
if (Dic_Data.ContainsKey(2))
{
if (RoleData.Select == null)
{
RoleData.Select = new RoleItem();
RoleData.Select.Column = Dic_Data[2];
}
else
{
RoleData.Select.Column = Dic_Data[2];
}
}
if (Dic_Data.ContainsKey(3))
{
if (RoleData.Select == null)
{
RoleData.Select = new RoleItem();
RoleData.Select.Filter = Dic_Data[3];
}
else
{
RoleData.Select.Filter = Dic_Data[3];
}
}
if (Dic_Data.ContainsKey(4))
{
if (RoleData.Insert == null)
{
RoleData.Insert = new RoleItem();
RoleData.Insert.Table = Dic_Data[4];
}
else
{
RoleData.Insert.Table = Dic_Data[4];
}
}
if (Dic_Data.ContainsKey(5))
{
if (RoleData.Insert == null)
{
RoleData.Insert = new RoleItem();
RoleData.Insert.Column = Dic_Data[5];
}
else
{
RoleData.Insert.Column = Dic_Data[5];
}
}
if (Dic_Data.ContainsKey(6))
{
if (RoleData.Insert == null)
{
RoleData.Insert = new RoleItem();
RoleData.Insert.Filter = Dic_Data[6];
}
else
{
RoleData.Insert.Filter = Dic_Data[6];
}
}
if (Dic_Data.ContainsKey(7))
{
if (RoleData.Update == null)
{
RoleData.Update = new RoleItem();
RoleData.Update.Table = Dic_Data[7];
}
else
{
RoleData.Update.Table = Dic_Data[7];
}
}
if (Dic_Data.ContainsKey(8))
{
if (RoleData.Update == null)
{
RoleData.Update = new RoleItem();
RoleData.Update.Column = Dic_Data[8];
}
else
{
RoleData.Update.Column = Dic_Data[8];
}
}
if (Dic_Data.ContainsKey(9))
{
if (RoleData.Update == null)
{
RoleData.Update = new RoleItem();
RoleData.Update.Filter = Dic_Data[9];
}
else
{
RoleData.Update.Filter = Dic_Data[9];
}
}
if (Dic_Data.ContainsKey(10))
{
if (RoleData.Delete == null)
{
RoleData.Delete = new RoleItem();
RoleData.Delete.Table = Dic_Data[10];
}
else
{
RoleData.Delete.Table = Dic_Data[10];
}
}
if (Dic_Data.ContainsKey(11))
{
if (RoleData.Delete == null)
{
RoleData.Delete = new RoleItem();
RoleData.Delete.Column = Dic_Data[11];
}
else
{
RoleData.Delete.Column = Dic_Data[11];
}
}
if (Dic_Data.ContainsKey(12))
{
if (RoleData.Delete == null)
{
RoleData.Delete = new RoleItem();
RoleData.Delete.Filter = Dic_Data[12];
}
else
{
RoleData.Delete.Filter = Dic_Data[12];
}
}
RoleData.Name = tablerole[0].rolecode;
ListRole.Add(RoleData);
return(ListRole);
}
