protected void btnCreate_Click(object sender, EventArgs e)
{
// var model1 = new MemberModel();
// IAction<MemberModel> actionobj = new MemberAction();
var model = new MemberModel(Convert.ToInt32(ddlPlan.SelectedValue),
txtFirstName.Text,
txtLastName.Text,
Convert.ToDateTime(txtDateOfBirth.Text).ToShortDateString(),
txtGender.Text,
txtUserName.Text);
if (txtFirstName.Text == string.Empty || txtLastName.Text == string.Empty || txtDateOfBirth.Text == string.Empty || txtGender.Text == string.Empty || txtUserName.Text == string.Empty)
{
txtFirstName.Text = "";
txtLastName.Text = "";
txtDateOfBirth.Text = "";
txtGender.Text = "";
txtUserName.Text = "";
}
else
{
var result = new MemberAction().Insert(model);
if (result == true)
{
lblResult.Text = "Member Has Been Added Successfully! ";
}
else
{
lblResult.Text = "Member Is Not Added ";
}
}
}
public ActionResult AccountManager()
{
if (Session["role"] != null && (string)Session["role"] == "Manager")
{
var tmp = AccountAction.Get_Account();
ViewBag.Account = tmp;
ViewBag.Member = MemberAction.Get_Account_Member();
List <string> lst_account = new List <string>();
for (int i = 0; i < tmp.Count; i++)
{
if (MemberAction.Find_By_Id_User(tmp[i].username) == null)
{
lst_account.Add(tmp[i].username);
}
}
ViewBag.Username = lst_account;
using (var db = new DBConnection())
{
int cnt = db.DbMemberShip.Count();
ViewBag.Page = cnt / 10 + (cnt % 10 == 0 ? 0 : 1);
db.Dispose();
}
return(View());
}
else
{
return(Redirect("~/Home/Index"));
}
}
public static string CSharpName(this MemberInfo member, MemberAction action)
{
if (member is MethodInfo && ((MethodInfo)member).IsOperator())
{
return(OperatorUtility.operatorAlternativeNames[member.Name]);
}
if (member is ConstructorInfo)
{
return("new " + member.DeclaringType.CSharpName());
}
var memberName = member.Name;
if (member is PropertyInfo propertyInfo && propertyInfo.IsIndexer())
{
memberName = "[]";
}
if ((member is FieldInfo || member is PropertyInfo) && action != MemberAction.None)
{
return($"{memberName} ({action.ToString().ToLower()})");
}
return(memberName);
}
protected void btnUpdate_Click(object sender, EventArgs e)
{
var obj = new MemberModel();
obj.FirstName = firstname.Text;
obj.Lastname = lastname.Text;
obj.Dob = Convert.ToDateTime(dob.Text).ToShortDateString();
obj.Gender = gender.Text;
obj.Username = username.Text;
obj.PlanId = Convert.ToInt32(ddlPlan.SelectedValue);
obj.MemberId = Convert.ToInt32(ViewState["Mem_id"]);
var result = new MemberAction().Update(obj);
if (result)
{
Label1.Text = "Member Has Been Updated Successfully!";
}
else
{
Label1.Text = "Error to delete -> ";
}
BindData();
udp.Update();
}
public ActionResult Login(string Username, string Password)
{
var result = AccountAction.Check_Login(Username, Password);
if (result != null)
{
Session["id"] = result.username;
var name = MemberAction.Find_By_Id_User(result.username);
if (name != null)
{
Session["name"] = name.fullname;
}
Session["role"] = result.role;
if (result.role == "Manager")
{
return(Redirect("~/Manager/ProductManager"));
}
else
{
return(Redirect("~/Home/ShowProduct"));
}
}
else
{
return(Redirect("~/Home/Index"));
}
}
public string SearchResultLabel(string query, MemberAction action, bool expectingBoolean)
{
var label = SearchUtility.HighlightQuery(Haystack(action, expectingBoolean), query);
if (value.isInvocable)
{
label += $" ({value.methodBase.DisplayParameterString()})";
}
return(label);
}
public ActionResult AccountRestore()
{
if (Session["role"] != null && (string)Session["role"] == "Manager")
{
ViewBag.Member = MemberAction.Get_Member_Delete();
return(View());
}
else
{
return(Redirect("~/Home/Index"));
}
}
//-------------------------------------------------------------------------------------------------------------------------------------------------
public void ForEach(MemberAction action)
{
for (int index = 0; index < m_SelectedMembers.Length; index++)
{
var member = m_SelectedMembers[index];
using (CreateTemplateScope(member))
{
action(index, m_SelectedMembers.Length, member);
}
}
}
/// <summary>
/// 绘制一个龙骨杆件
/// </summary>
public MemberAction MemberAction(Color?penColor = null, int lineWidth = 1, Color?fill = null, dynamic Element = null)
{
if (penColor == null)
{
penColor = Colors.Black;
}
var a = new MemberAction();
a.Geometry.PenColor = penColor.Value;
a.Geometry.LineWidth = lineWidth;
a.Geometry.Element = Element;
if (fill != null)
{
a.Geometry.FillColor = fill.Value;
}
DrawingControl.SetAction(a);
LastAction = a;
return(a);
}
public MemberOption(Member member, MemberAction action, bool expectingBoolean) : base(FuzzyOptionMode.Leaf)
{
Ensure.That(nameof(member)).IsNotNull(member);
value = member;
documentation = new XmlFuzzyOptionDocumentation(member.info.Documentation());
getIcon = () => member.pseudoDeclaringType.Icon();
if (member.isPseudoInherited)
{
dim = true;
}
if (member.isInvocable)
{
label = $"{member.info.DisplayName(action, expectingBoolean)} ({member.methodBase.DisplayParameterString()})";
}
else
{
label = member.info.DisplayName(action, expectingBoolean);
}
}
public static EditorTexture Member(MemberInfo member, MemberAction action)
{
Ensure.That(nameof(member)).IsNotNull(member);
var method = member as MethodInfo;
var field = member as FieldInfo;
var property = member as PropertyInfo;
var constructor = member as ConstructorInfo;
if (method != null)
{
if (method.IsExtension())
{
return(Language.extensionMethod.@public);
}
if (method.IsPrivate)
{
return(Language.method.@private);
}
if (method.IsFamily)
{
return(Language.method.@protected);
}
if (method.IsAssembly)
{
return(Language.method.@internal);
}
if (method.IsPublic)
{
return(Language.method.@public);
}
}
else if (constructor != null)
{
if (constructor.IsPrivate)
{
return(Language.constructor.@private);
}
if (constructor.IsFamily)
{
return(Language.constructor.@protected);
}
if (constructor.IsAssembly)
{
return(Language.constructor.@internal);
}
if (constructor.IsPublic)
{
return(Language.constructor.@public);
}
}
else if (field != null)
{
if (field.IsLiteral)
{
if (field.IsPrivate)
{
return(Language.method.@private);
}
if (field.IsFamily)
{
return(Language.method.@protected);
}
if (field.IsAssembly)
{
return(Language.method.@internal);
}
if (field.IsPublic)
{
return(Language.method.@public);
}
}
else
{
if (field.IsPrivate)
{
return(Language.method.@private);
}
if (field.IsFamily)
{
return(Language.method.@protected);
}
if (field.IsAssembly)
{
return(Language.method.@internal);
}
if (field.IsPublic)
{
return(Language.method.@public);
}
}
}
else if (property != null)
{
var accessors = property.GetAccessors(true);
var getter = accessors.FirstOrDefault(accessor => accessor.ReturnType != typeof(void));
var setter = accessors.FirstOrDefault(accessor => accessor.ReturnType == typeof(void));
bool isPrivate, isProtected, isInternal, isPublic;
if (action == MemberAction.None)
{
isPrivate = getter == null || getter.IsPrivate || setter == null || setter.IsPrivate;
if (isPrivate)
{
isProtected = false;
isInternal = false;
isPublic = false;
}
else
{
isProtected = getter.IsFamily || setter.IsFamily;
isInternal = getter.IsAssembly || setter.IsAssembly;
isPublic = getter.IsPublic && setter.IsPublic;
}
}
else if (action == MemberAction.Get && getter != null)
{
isPrivate = getter.IsPrivate;
isProtected = getter.IsFamily;
isInternal = getter.IsAssembly;
isPublic = getter.IsPublic;
}
else if (action == MemberAction.Set && setter != null)
{
isPrivate = setter.IsPrivate;
isProtected = setter.IsFamily;
isInternal = setter.IsAssembly;
isPublic = setter.IsPublic;
}
else
{
return(null);
}
if (isPrivate)
{
return(Language.property.@private);
}
if (isProtected)
{
return(Language.property.@protected);
}
if (isInternal)
{
return(Language.property.@internal);
}
if (isPublic)
{
return(Language.property.@public);
}
}
return(null);
}
public static EditorTexture Icon(this MemberInfo member, MemberAction action = MemberAction.None)
{
return(Member(member, action));
}
public JsonResult Get_Member(string Id)
{
return(Json(MemberAction.Find_By_Id_User(Id), JsonRequestBehavior.AllowGet));
}
public JsonResult Validation_Member(string Username)
{
return(Json(MemberAction.Find_By_Id_User(Username), JsonRequestBehavior.AllowGet));
}
private string MemberNameWithTargetType(MemberAction action, bool expectingBoolean)
{
return($"{value.targetType.DisplayName()}{(LudiqCore.Configuration.humanNaming ? ": " : ".")}{value.info.DisplayName(action, expectingBoolean)}");
}
public static string HumanName(this MemberInfo member, MemberAction action = MemberAction.None, bool expectingBoolean = false)
{
var words = member.Name.Prettify();
if (member is MethodInfo methodInfo)
{
if (methodInfo.IsOperator())
{
return(OperatorUtility.operatorHumanNames[methodInfo.Name]);
}
else
{
return(words);
}
}
else if (member is FieldInfo || member is PropertyInfo)
{
if (action == MemberAction.None)
{
return(words);
}
var type = member is FieldInfo ? ((FieldInfo)member).FieldType : ((PropertyInfo)member).PropertyType;
// Fix for Unity's object-to-boolean implicit null-check operators
if (action == MemberAction.Get && typeof(UnityObject).IsAssignableFrom(type) && expectingBoolean)
{
return(words + " Is Not Null");
}
var verb = Verb(action);
if (type == typeof(bool))
{
// Check for boolean verbs like IsReady, HasChildren, etc.
if (words.Contains(' ') && booleanVerbs.Contains(words.Split(' ')[0]))
{
// Return them as-is for gets
if (action == MemberAction.Get)
{
return(words);
}
// Skip them for sets
else if (action == MemberAction.Set)
{
return(verb + " " + words.Substring(words.IndexOf(' ') + 1));
}
else
{
throw new UnexpectedEnumValueException <MemberAction>(action);
}
}
else
{
return(verb + " " + words);
}
}
else if (action == MemberAction.Get && member.IsStatic() && !member.IsExtensionMethod())
{
return(words);
}
// Otherwise, add get/set the verb prefix
else
{
return(verb + " " + words);
}
}
else if (member is ConstructorInfo)
{
return("Create " + member.DeclaringType.HumanName());
}
else if (member is EventInfo)
{
return(words);
}
else
{
throw new UnexpectedEnumValueException <MemberAction>(action);
}
}
public static string Verb(this MemberAction action)
{
return(action.ToString());
}
public MemberOptionTree(UnityObject target, MemberFilter memberFilter, TypeFilter memberTypeFilter, MemberAction action)
: this(EditorUnityObjectUtility.GetUnityTypes(target), memberFilter, memberTypeFilter, action)
{
rootMode = RootMode.Types;
}
public string Haystack(MemberAction action, bool expectingBoolean)
{
return(MemberNameWithTargetType(action, expectingBoolean));
}
public InspectorActionDirectionAttribute(MemberAction action)
{
this.action = action;
}
public static string SelectedName(this MemberInfo member, bool human, MemberAction action = MemberAction.None, bool expectingBoolean = false)
{
return(human ? member.HumanName(action) : member.CSharpName(action));
}
public static string DisplayName(this MemberInfo member, MemberAction action = MemberAction.None, bool expectingBoolean = false)
{
return(SelectedName(member, LudiqCore.Configuration.humanNaming, action, expectingBoolean));
}
public ActionResult UndeleteMember(string ID)
{
MemberAction.Restore_Member(ID);
AccountAction.Restore_Account(ID);
return(Redirect("~/Account/AccountRestore"));
}
public ActionResult DeleteMember(string ID)
{
AccountAction.Delete_Account(ID);
MemberAction.Delete_Member(ID);
return(Redirect("~/Account/AccountManager"));
}
public MemberOptionTree(IEnumerable <Type> types, MemberFilter memberFilter, TypeFilter memberTypeFilter, MemberAction action) : base(new GUIContent("Member"))
{
favorites = new Favorites(this);
codebase = Codebase.Subset(types, memberFilter.Configured(), memberTypeFilter?.Configured());
this.action = action;
this.types = types;
this.memberFilter = memberFilter;
this.memberTypeFilter = memberTypeFilter;
expectingBoolean = memberTypeFilter?.ExpectsBoolean ?? false;
}
public ActionResult CreateMember(string FullName, string Date_Of_Birth, string ID_User, string Address, string Phone,
string Email, string ID_Card, string Gender)
{
MemberAction.Create_Member(FullName, Date_Of_Birth, ID_User, Address, Phone, Email, ID_Card, Gender);
return(Redirect("~/Account/AccountManager"));
}
/// <summary>
/// Creates a new method in the target assembly, for the specified type.
/// </summary>
/// <returns></returns>
/// <exception cref="PatchDeclerationException">Thrown if this member collides with another member, and the error cannot be resolved.</exception>
private MethodDefinition CreateNewMethod(MemberAction<MethodDefinition> memberAction)
{
var actionAttribute = (NewMemberAttribute)memberAction.ActionAttribute;
var yourMethod = memberAction.YourMember;
var targetDeclaringType = memberAction.TypeAction.TargetType;
var newName = actionAttribute.NewMemberName ?? yourMethod.Name;
if (actionAttribute.IsImplicit) {
Log_implicitly_creating_member("method", yourMethod);
} else {
Log_creating_member("method", yourMethod);
}
var maybeDuplicate = targetDeclaringType.GetMethodLike(yourMethod, newName);
if (maybeDuplicate != null) {
var prevName = newName;
Log_duplicate_member("method", yourMethod, maybeDuplicate);
newName = GetNameAfterCollision(newName);
Log_name_changed("method", yourMethod, prevName, newName);
}
var targetMethod = CopyMethod(yourMethod, newName);
memberAction.TargetMember = targetMethod;
targetDeclaringType.Methods.Add(targetMethod);
return targetMethod;
}
public ActionResult UpdateMember(int ID, string FullName, string Date_Of_Birth, string Address, string Phone,
string Email, string ID_Card, string Gender)
{
MemberAction.Update_Member(ID, FullName, Date_Of_Birth, Address, Phone, Email, ID_Card, Gender);
return(Redirect("~/Account/AccountManager"));
}
