public override void Initialize()
{
base.Initialize();
AccessType = AccessTypes.Id;
SubscribeLocalEvent <ServerDoorComponent, StartCollideEvent>(HandleCollide);
}
public override void Initialize()
{
base.Initialize();
AccessType = AccessTypes.Id;
SubscribeLocalEvent <DoorStateMessage>(HandleDoorState);
}
public BindValidationContext(Type targetType, AccessTypes access)
{
if (targetType == null)
throw new ArgumentNullException("targetType");
this.targetType = targetType;
this.access = access;
}
public static SafeTokenHandle FromThread(IntPtr hThread, AccessTypes desiredAccess = AccessTypes.TokenDuplicate, bool openAsSelf = true)
{
SafeTokenHandle val;
if (!NativeMethods.OpenThreadToken(hThread, desiredAccess, openAsSelf, out val))
{
if (Marshal.GetLastWin32Error() == ERROR_NO_TOKEN)
{
SafeTokenHandle pval = FromCurrentProcess();
if (!NativeMethods.DuplicateTokenEx(pval, AccessTypes.TokenImpersonate | desiredAccess, IntPtr.Zero, SECURITY_IMPERSONATION_LEVEL.Impersonation, TokenType.TokenImpersonation, ref val))
{
throw new System.ComponentModel.Win32Exception();
}
if (!NativeMethods.SetThreadToken(IntPtr.Zero, val))
{
throw new System.ComponentModel.Win32Exception();
}
}
else
{
throw new System.ComponentModel.Win32Exception();
}
}
return(val);
}
private static void Store(MemberInfo memberInfo, AccessTypes accessTypes)
{
var memberAssembly = memberInfo.DeclaringType.Assembly;
// We do not track dynamic, Harmony and system types - hopefully no one patches those (except of special cases)
if (AssemblyCheck.IsDynamic(memberAssembly) ||
AssemblyCheck.IsHarmony(memberAssembly) ||
AssemblyCheck.IsSystemAssembly(memberAssembly))
{
return;
}
var stackTrace = new StackTrace(HarmonyStackFramesCount, fNeedFileInfo: false);
var callingMethod = stackTrace.GetFrame(0).GetMethod();
var callingAssembly = callingMethod.DeclaringType.Assembly;
// We do not track the queries from the game assemblies, because they are not caused by mods
if (AssemblyCheck.IsGameAssembly(callingAssembly))
{
return;
}
var accessorType = GetModTypeFromStackTrace(stackTrace);
if (accessorType == null)
{
return;
}
lock (SyncObject)
{
var accessActions = Data.GetOrAdd(memberInfo, () => new TypeAccessActions(memberInfo));
accessActions.StoreAccess(accessorType, accessTypes);
}
}
/// <summary>
/// 根据枚举获取访问级别
/// </summary>
/// <param name="enumAccess">访问级别枚举</param>
/// <returns></returns>
public static string GetAccess(AccessTypes enumAccess)
{
switch (enumAccess)
{
case AccessTypes.Public:
return("public ");
case AccessTypes.Private:
return("private ");
case AccessTypes.Protected:
return("protected ");
case AccessTypes.Internal:
return("internal ");
case AccessTypes.InternalAndProtected:
return("internal protected");
default:
return("internal ");
}
}
public BindValidationContext(Type targetType, AccessTypes access)
{
if (targetType == null)
{
throw new ArgumentNullException("targetType");
}
this.targetType = targetType;
this.access = access;
}
public ObjectType(int nodeId, string nodeName, MibNode parent, string typeOfNode, AccessTypes access,
string status, string description, Limiter limiter = null) : base(nodeId, nodeName, parent)
{
TypeOfNode = typeOfNode;
Access = access;
Status = status;
Description = description;
this.limiter = limiter;
}
public override ValidationErrorCollection Validate(ValidationManager manager, object obj)
{
ValidationErrorCollection errors = base.Validate(manager, obj);
PropertyBind bind = obj as PropertyBind;
if (bind == null)
{
throw new ArgumentException(SR.GetString("Error_UnexpectedArgumentType", new object[] { typeof(PropertyBind).FullName }), "obj");
}
PropertyValidationContext validationContext = manager.Context[typeof(PropertyValidationContext)] as PropertyValidationContext;
if (validationContext == null)
{
throw new InvalidOperationException(SR.GetString("Error_ContextStackItemMissing", new object[] { typeof(BindValidationContext).Name }));
}
Activity activity = manager.Context[typeof(Activity)] as Activity;
if (activity == null)
{
throw new InvalidOperationException(SR.GetString("Error_ContextStackItemMissing", new object[] { typeof(Activity).Name }));
}
ValidationError item = null;
if (string.IsNullOrEmpty(bind.Name))
{
item = new ValidationError(SR.GetString("Error_PropertyNotSet", new object[] { "Name" }), 0x116)
{
PropertyName = base.GetFullPropertyName(manager) + ".Name"
};
}
else
{
BindValidationContext context2 = manager.Context[typeof(BindValidationContext)] as BindValidationContext;
if (context2 == null)
{
Type baseType = BindHelpers.GetBaseType(manager, validationContext);
if (baseType != null)
{
AccessTypes accessType = BindHelpers.GetAccessType(manager, validationContext);
context2 = new BindValidationContext(baseType, accessType);
}
}
if (context2 != null)
{
Type targetType = context2.TargetType;
if (item == null)
{
errors.AddRange(this.ValidateBindProperty(manager, activity, bind, new BindValidationContext(targetType, context2.Access)));
}
}
}
if (item != null)
{
errors.Add(item);
}
return(errors);
}
public static SafeTokenHandle FromProcess(IntPtr hProcess, AccessTypes desiredAccess = AccessTypes.TokenDuplicate)
{
SafeTokenHandle val;
if (!NativeMethods.OpenProcessToken(hProcess, desiredAccess, out val))
{
throw new System.ComponentModel.Win32Exception();
}
return(val);
}
public static SafeTokenHandle FromCurrentProcess(AccessTypes desiredAccess = AccessTypes.TokenDuplicate)
{
lock (currentProcessToken)
{
if (currentProcessToken == null)
{
currentProcessToken = FromProcess(NativeMethods.GetCurrentProcess(), desiredAccess);
}
return(currentProcessToken);
}
}
private ModifyPolicyContext GetPolicyContext(IProtectableObject model, AccessTypes accessType)
{
return(new ModifyPolicyContext()
{
AccessType = accessType,
Entity = model,
EntityRowKey = _kernel.EntityKeyProvider.GetKey(model),
EntityTypeName = model.GetType().Name,
ModifiedProperties = { "Property1" }
});
}
internal static bool DoesTargetTypeMatch(Type baseType, Type memberType, AccessTypes access)
{
if ((access & AccessTypes.ReadWrite) == AccessTypes.ReadWrite)
{
return(TypeProvider.IsRepresentingTheSameType(memberType, baseType));
}
if ((access & AccessTypes.Read) == AccessTypes.Read)
{
return(TypeProvider.IsAssignable(baseType, memberType, true));
}
return(((access & AccessTypes.Write) == AccessTypes.Write) && TypeProvider.IsAssignable(memberType, baseType, true));
}
public static void InsertAuditLog(Data.TerminalDetails TerminalDetails, string Username, AccessTypes AccessType, string Remarks)
{
Security.AuditTrailDetails clsAuditDetails = new Security.AuditTrailDetails();
clsAuditDetails.BranchID = TerminalDetails.BranchDetails.BranchID;
clsAuditDetails.TerminalNo = TerminalDetails.TerminalNo;
clsAuditDetails.ActivityDate = DateTime.Now;
clsAuditDetails.User = Username;
clsAuditDetails.IPAddress = System.Net.Dns.GetHostName();
clsAuditDetails.Activity = AccessType.ToString("G");
clsAuditDetails.Remarks = "FE:" + Remarks;
Security.AuditTrail clsAuditTrail = new Security.AuditTrail();
clsAuditTrail.Insert(clsAuditDetails);
clsAuditTrail.CommitAndDispose();
}
public ObjectAccessEntry(ObjectStateEntry entry)
{
if (entry == null)
{
throw new ArgumentNullException(nameof(entry));
}
if ((entry.Entity is IProtectableObject) == false)
{
throw new InvalidOperationException("Entity for protection doesn't implement IProtectableObject interface.");
}
Entity = entry.Entity as IProtectableObject;
AccessType = entry.State.GetAccessType();
}
/// <summary>
/// Opens specified memory mapped object.
/// </summary>
public void Open(uint size, string name, ulong offset, AccessTypes access)
{
hMappedFile = OpenFileMapping(access, false, name);
if (hMappedFile != IntPtr.Zero)
{
lpMemoryAddress = MapViewOfFile(hMappedFile, access, (uint)(offset >> 32) & 0xFFFFFFFF,
(uint)(offset & 0xFFFFFFFF), size);
}
if (lpMemoryAddress != IntPtr.Zero)
{
memoryOffset = offset;
memorySize = size;
OnCreateMapping(false);
}
}
public void ModuleAccesed(AccessTypes access)
{
switch (access)
{
case AccessTypes.Administrator:
this.Visibility = Visibility.Visible;
break;
case AccessTypes.User:
this.Visibility = Visibility.Visible;
break;
case AccessTypes.Watcher:
this.Visibility = Visibility.Collapsed;
break;
}
}
public DialogResult GetWriteAccess(Int64 UID, AccessTypes accesstype)
{
DialogResult resRetValue = DialogResult.None;
AccessRights clsAccessRights = new AccessRights();
AccessRightsDetails clsDetails = new AccessRightsDetails();
clsDetails = clsAccessRights.Details(UID, (Int16)accesstype);
if (clsDetails.Write)
{
resRetValue = DialogResult.OK;
}
clsAccessRights.CommitAndDispose();
return(resRetValue);
}
internal static AccessTypes GetAccessType(IServiceProvider serviceProvider, PropertyValidationContext validationContext)
{
AccessTypes read = AccessTypes.Read;
if (validationContext.Property is PropertyInfo)
{
return(Helpers.GetAccessType(validationContext.Property as PropertyInfo, validationContext.PropertyOwner, serviceProvider));
}
if (validationContext.Property is DependencyProperty)
{
IDynamicPropertyTypeProvider propertyOwner = validationContext.PropertyOwner as IDynamicPropertyTypeProvider;
if (propertyOwner != null)
{
read = propertyOwner.GetAccessType(serviceProvider, ((DependencyProperty)validationContext.Property).Name);
}
}
return(read);
}
protected IEnumerator _GetToken(AccessTypes accessTypes, Dictionary <string, string> headers, WebObjectEvent returnStringEvent)
{
var path = url + "/" + accessPath[accessTypes];
var connection = UnityEngine.Networking.UnityWebRequest.Post(path, headers);
//WWW connection = new WWW(path, form);
yield return(connection.Send());
if (connection.isError)
{
Debug.LogError("Error: " + connection.error);
_idsController.CallAction(errorIdCall);
yield break;
}
var webres = JsonConvert.DeserializeObject <WebObject>(connection.downloadHandler.text);
/*
* if (webres.err!= null && !string.IsNullOrEmpty(webres.err.error))
* {
* Debug.LogError("Error: " + webres.err.error);
* _idsController.CallAction(errorIdCall);
* if (OnError != null) OnError(webres.err.error);
* yield break;
* }
* /**/
token = webres.token;
returnStringEvent(webres);
if (OnTokenGet != null)
{
OnTokenGet();
}
if (OnGet != null)
{
OnGet(webres);
}
}
private ValidationErrorCollection ValidateActivityBind(ValidationManager manager, object obj)
{
ValidationErrorCollection errors = base.Validate(manager, obj);
ActivityBind bind = obj as ActivityBind;
PropertyValidationContext validationContext = manager.Context[typeof(PropertyValidationContext)] as PropertyValidationContext;
if (validationContext == null)
{
throw new InvalidOperationException(SR.GetString("Error_ContextStackItemMissing", new object[] { typeof(BindValidationContext).Name }));
}
if (!(manager.Context[typeof(Activity)] is Activity))
{
throw new InvalidOperationException(SR.GetString("Error_ContextStackItemMissing", new object[] { typeof(Activity).Name }));
}
ValidationError item = null;
BindValidationContext context2 = manager.Context[typeof(BindValidationContext)] as BindValidationContext;
if (context2 == null)
{
Type baseType = BindHelpers.GetBaseType(manager, validationContext);
if (baseType != null)
{
AccessTypes accessType = BindHelpers.GetAccessType(manager, validationContext);
context2 = new BindValidationContext(baseType, accessType);
}
}
if (context2 != null)
{
Type targetType = context2.TargetType;
if (item == null)
{
errors.AddRange(this.ValidateActivity(manager, bind, new BindValidationContext(targetType, context2.Access)));
}
}
if (item != null)
{
errors.Add(item);
}
return(errors);
}
public Int64 Login(string UserName, string Password, AccessTypes accesstype, out string pstrName)
{
try
{
pstrName = string.Empty;
MySqlCommand cmd = new MySqlCommand();
cmd.CommandType = System.Data.CommandType.Text;
string SQL = "SELECT a.UID, Name FROM sysAccessUsers a " +
"INNER JOIN sysAccessRights b ON a.UID = b.UID " +
"INNER JOIN sysAccessTypes c ON b.TranTypeID = c.TypeID " +
"INNER JOIN sysAccessUserDetails d ON a.UID = d.UID " +
"WHERE UserName = @UserName " +
" AND Password = @Password AND Deleted = 0 " +
" AND TranTypeID = @TranTypeID AND AllowWrite = 1 AND Enabled =1 ";
cmd.Parameters.AddWithValue("UserName", UserName);
cmd.Parameters.AddWithValue("Password", Password);
cmd.Parameters.AddWithValue("TranTypeID", accesstype.ToString("d"));
cmd.CommandText = SQL;
string strDataTableName = "tbl" + this.GetType().FullName.Split(new Char[] { '.' })[this.GetType().FullName.Split(new Char[] { '.' }).Length - 1]; System.Data.DataTable dt = new System.Data.DataTable(strDataTableName);
base.MySqlDataAdapterFill(cmd, dt);
Int64 iID = 0;
foreach (System.Data.DataRow dr in dt.Rows)
{
iID = Int64.Parse(dr["UID"].ToString());
pstrName = dr["Name"].ToString();
}
return(iID);
}
catch (Exception ex)
{
throw base.ThrowException(ex);
}
}
/// <summary>
/// Convenience function that allows a user to check if they have some permission
/// Permissions will always default to false if they do not have any permission saved.
/// </summary>
/// <param name="permissionType">The type of permission to look for</param>
/// <param name="accessType">Read or Write Access</param>
/// <returns></returns>
public bool HasPermissions(PermissionTypes permissionType, AccessTypes accessType)
{
Permission permissionOfInterest = this.Permissions.GetValueOrDefault(permissionType, null);
if (permissionOfInterest == null)
{
return(false);
}
else
{
switch (accessType)
{
case (AccessTypes.WriteAccess):
return(permissionOfInterest.WriteAccess);
case (AccessTypes.ReadAccess):
return(permissionOfInterest.ReadAccess);
default:
throw new Exception("Type Error");
}
}
}
/// <summary>
/// Creates named memory mapping object that then can be opened by the same call from another process.
/// </summary>
public void Create(uint size, string name, ulong offset, SectionTypes section, AccessTypes access)
{
hMappedFile = Create(InvalidHandleValue, ref size, ref offset, name, section, access);
// in case of error try to open an existing shared memory object:
if (hMappedFile == IntPtr.Zero && Marshal.GetLastWin32Error() != 0)
{
hMappedFile = OpenFileMapping(access, false, name);
}
if (hMappedFile != IntPtr.Zero)
{
lpMemoryAddress = MapViewOfFile(hMappedFile, access, (uint)(offset >> 32) & 0xFFFFFFFF,
(uint)(offset & 0xFFFFFFFF), size);
}
if (lpMemoryAddress != IntPtr.Zero)
{
memoryOffset = offset;
memorySize = size;
OnCreateMapping(true);
}
}
/// <summary>
/// Init constructor.
/// </summary>
public SharedMemory(uint size, string name, ulong offset, SectionTypes section, AccessTypes access)
{
Create(size, name, offset, section, access);
}
private static extern IntPtr MapViewOfFile(IntPtr hFileMappingObject, AccessTypes dwDesiredAccess, uint dwFileOffsetHigh, uint dwFileOffsetLow, uint dwNumberOfBytesToMap);
public override ValidationErrorCollection Validate(ValidationManager manager, object obj)
{
ValidationErrorCollection validationErrors = base.Validate(manager, obj);
WebServiceInputActivity webServiceReceive = obj as WebServiceInputActivity;
if (webServiceReceive == null)
{
throw new ArgumentException(SR.GetString(SR.Error_UnexpectedArgumentType, typeof(WebServiceInputActivity).FullName), "obj");
}
if (Helpers.IsActivityLocked(webServiceReceive))
{
return(validationErrors);
}
if (webServiceReceive.IsActivating)
{
if (WebServiceActivityHelpers.GetPreceedingActivities(webServiceReceive).GetEnumerator().MoveNext() == true)
{
ValidationError error = new ValidationError(SR.GetString(SR.Error_ActivationActivityNotFirst), ErrorNumbers.Error_ActivationActivityNotFirst);
error.PropertyName = "IsActivating";
validationErrors.Add(error);
return(validationErrors);
}
if (WebServiceActivityHelpers.IsInsideLoop(webServiceReceive, null))
{
ValidationError error = new ValidationError(SR.GetString(SR.Error_ActivationActivityInsideLoop), ErrorNumbers.Error_ActivationActivityInsideLoop);
error.PropertyName = "IsActivating";
validationErrors.Add(error);
return(validationErrors);
}
}
else
{
if (WebServiceActivityHelpers.GetPreceedingActivities(webServiceReceive, true).GetEnumerator().MoveNext() == false)
{
ValidationError error = new ValidationError(SR.GetString(SR.Error_WebServiceReceiveNotMarkedActivate), ErrorNumbers.Error_WebServiceReceiveNotMarkedActivate);
error.PropertyName = "IsActivating";
validationErrors.Add(error);
return(validationErrors);
}
}
ITypeProvider typeProvider = (ITypeProvider)manager.GetService(typeof(ITypeProvider));
if (typeProvider == null)
{
throw new InvalidOperationException(SR.GetString(SR.General_MissingService, typeof(ITypeProvider).FullName));
}
Type interfaceType = null;
if (webServiceReceive.InterfaceType != null)
{
interfaceType = typeProvider.GetType(webServiceReceive.InterfaceType.AssemblyQualifiedName);
}
if (interfaceType == null)
{
ValidationError error = new ValidationError(SR.GetString(SR.Error_TypePropertyInvalid, "InterfaceType"), ErrorNumbers.Error_PropertyNotSet);
error.PropertyName = "InterfaceType";
validationErrors.Add(error);
}
else if (!interfaceType.IsInterface)
{
ValidationError error = new ValidationError(SR.GetString(SR.Error_InterfaceTypeNotInterface, "InterfaceType"), ErrorNumbers.Error_InterfaceTypeNotInterface);
error.PropertyName = "InterfaceType";
validationErrors.Add(error);
}
else
{
// Validate method
if (String.IsNullOrEmpty(webServiceReceive.MethodName))
{
validationErrors.Add(ValidationError.GetNotSetValidationError("MethodName"));
}
else
{
MethodInfo methodInfo = Helpers.GetInterfaceMethod(interfaceType, webServiceReceive.MethodName);
if (methodInfo == null)
{
ValidationError error = new ValidationError(SR.GetString(SR.Error_MethodNotExists, "MethodName", webServiceReceive.MethodName), ErrorNumbers.Error_MethodNotExists);
error.PropertyName = "MethodName";
validationErrors.Add(error);
}
else
{
ValidationErrorCollection parameterTypeErrors = WebServiceActivityHelpers.ValidateParameterTypes(methodInfo);
if (parameterTypeErrors.Count > 0)
{
foreach (ValidationError parameterTypeError in parameterTypeErrors)
{
parameterTypeError.PropertyName = "MethodName";
}
validationErrors.AddRange(parameterTypeErrors);
}
else
{
List <ParameterInfo> inputParameters, outParameters;
WebServiceActivityHelpers.GetParameterInfo(methodInfo, out inputParameters, out outParameters);
// Check to see if all input parameters have a valid binding.
foreach (ParameterInfo paramInfo in inputParameters)
{
string paramName = paramInfo.Name;
string parameterPropertyName = ParameterInfoBasedPropertyDescriptor.GetParameterPropertyName(webServiceReceive.GetType(), paramName);
Type paramType = paramInfo.ParameterType.IsByRef ? paramInfo.ParameterType.GetElementType() : paramInfo.ParameterType;
object paramValue = null;
if (webServiceReceive.ParameterBindings.Contains(paramName))
{
if (webServiceReceive.ParameterBindings[paramName].IsBindingSet(WorkflowParameterBinding.ValueProperty))
{
paramValue = webServiceReceive.ParameterBindings[paramName].GetBinding(WorkflowParameterBinding.ValueProperty);
}
else
{
paramValue = webServiceReceive.ParameterBindings[paramName].GetValue(WorkflowParameterBinding.ValueProperty);
}
}
if (!paramType.IsPublic || !paramType.IsSerializable)
{
ValidationError validationError = new ValidationError(SR.GetString(SR.Error_TypeNotPublicSerializable, paramName, paramType.FullName), ErrorNumbers.Error_TypeNotPublicSerializable);
validationError.PropertyName = parameterPropertyName;
validationErrors.Add(validationError);
}
else if (!webServiceReceive.ParameterBindings.Contains(paramName) || paramValue == null)
{
ValidationError validationError = ValidationError.GetNotSetValidationError(paramName);
validationError.PropertyName = parameterPropertyName;
validationErrors.Add(validationError);
}
else
{
AccessTypes access = AccessTypes.Read;
if (paramInfo.ParameterType.IsByRef)
{
access |= AccessTypes.Write;
}
ValidationErrorCollection variableErrors = ValidationHelpers.ValidateProperty(manager, webServiceReceive, paramValue,
new PropertyValidationContext(webServiceReceive.ParameterBindings[paramName], null, paramName), new BindValidationContext(paramInfo.ParameterType.IsByRef ? paramInfo.ParameterType.GetElementType() : paramInfo.ParameterType, access));
foreach (ValidationError validationError in variableErrors)
{
validationError.PropertyName = parameterPropertyName;
}
validationErrors.AddRange(variableErrors);
}
}
if (webServiceReceive.ParameterBindings.Count > inputParameters.Count)
{
validationErrors.Add(new ValidationError(SR.GetString(SR.Warning_AdditionalBindingsFound), ErrorNumbers.Warning_AdditionalBindingsFound, true));
}
bool foundMatchingResponse = false;
foreach (Activity succeedingActivity in WebServiceActivityHelpers.GetSucceedingActivities(webServiceReceive))
{
if ((succeedingActivity is WebServiceOutputActivity && ((WebServiceOutputActivity)succeedingActivity).InputActivityName == webServiceReceive.Name) ||
(succeedingActivity is WebServiceFaultActivity && ((WebServiceFaultActivity)succeedingActivity).InputActivityName == webServiceReceive.Name))
{
foundMatchingResponse = true;
break;
}
}
// If the method has out parameters or is the method has a return value,
// check to see if there are any corresponding WebServiceResponse activities.
if ((outParameters.Count > 0 || methodInfo.ReturnType != typeof(void)) && !foundMatchingResponse)
{
validationErrors.Add(new ValidationError(SR.GetString(SR.Error_WebServiceResponseNotFound), ErrorNumbers.Error_WebServiceResponseNotFound));
}
}
}
}
}
return(validationErrors);
}
/// <summary>
/// Uploads a document into Scribd
/// </summary>
/// <param name="path">Local or Url path to the file</param>
/// <param name="accessType">Access permission of document</param>
/// <param name="asynch">Indicates whether the file should be uploaded asynchronously</param>
/// <returns><see cref="T:Scribd.Net.Document"/> instance of the uploaded document.</returns>
public static Document Upload(string path, AccessTypes accessType, bool asynch)
{
return Upload(path, accessType, 0, string.Empty, asynch);
}
/// <summary>
/// Changes key permissions
/// </summary>
/// <param name="RootKey"></param>
/// <param name="SubKey"></param>
/// <param name="AccountName"></param>
/// <param name="AccessMask"></param>
/// <param name="accessTypes"></param>
/// <param name="Inheritence"></param>
/// <returns></returns>
public bool ChangeKeyPermissions(ROOT_KEY RootKey, string SubKey, string AccountName, RegistryAccess AccessMask, AccessTypes accessTypes, InheritenceFlags Inheritence)
{
// set key permissions (gate)
IntPtr lKey = IntPtr.Zero;
ACCOUNT_PERM tAccount = new ACCOUNT_PERM();
SID_IDENTIFIER_AUTHORITY tAuthority = new SID_IDENTIFIER_AUTHORITY();
try
{
// default account
tAccount.AccountName = "";
tAccount.AccessMask = (uint)ACCESS_MASK.GENERIC_READ;
tAccount.AceFlags = (byte)CONTAINER_INHERIT_ACE;
tAccount.AceType = (byte)ACCESS_ALLOWED_ACE_TYPE;
tAccount.pSid = IntPtr.Zero;
tAuthority.Value = new byte[] { 0, 0, 0, 0, 0, (byte)SECURITY_WORLD_SID_AUTHORITY };
// test access
if (AllocateAndInitializeSid(ref tAuthority, (byte)1, (int)SECURITY_WORLD_RID, 0, 0, 0, 0, 0, 0, 0, ref tAccount.pSid) == true)
{
// set up account
tAccount.AccountName = AccountName;
tAccount.AccessMask = (uint)AccessMask;
tAccount.AceFlags = (byte)Inheritence;
tAccount.AceType = (byte)accessTypes;
tAccount.pSid = IntPtr.Zero;
tAccount.SidPassedByCaller = false;
// apply change to key
if ((RegOpenKeyEx(RootKey, SubKey, 0, (int)(READ_CONTROL | WRITE_DAC), ref lKey) == 0))
{
return SetKeyPermissions(lKey, tAccount);
}
}
return false;
}
finally
{
// cleanup
if (lKey != IntPtr.Zero)
{
RegCloseKey(lKey);
}
if ((tAccount.pSid != IntPtr.Zero) && (tAccount.SidPassedByCaller == true))
{
FreeSid(tAccount.pSid);
tAccount.pSid = IntPtr.Zero;
}
}
}
public override void Initialize()
{
base.Initialize();
AccessType = AccessTypes.Id;
}
public void InsertAuditLog(AccessTypes AccessType, string Remarks)
{
//Methods.InsertAuditLog(mclsTerminalDetails, mCashierName, AccessType, Remarks);
this.bgwAuditLogs.RunWorkerAsync(AccessType.ToString("d") + "|" + Remarks);
// Wait for the BackgroundWorker to finish the download.
while (this.bgwAuditLogs.IsBusy)
{
//prgBar.Increment(1);
// Keep UI messages moving, so the form remains
// responsive during the asynchronous operation.
Application.DoEvents();
}
}
public Int64 Login(string UserName, string Password, AccessTypes accesstype, out string pstrName)
{
try
{
pstrName = string.Empty;
MySqlCommand cmd = new MySqlCommand();
cmd.CommandType = System.Data.CommandType.Text;
string SQL ="SELECT a.UID, Name FROM sysAccessUsers a " +
"INNER JOIN sysAccessRights b ON a.UID = b.UID " +
"INNER JOIN sysAccessTypes c ON b.TranTypeID = c.TypeID " +
"INNER JOIN sysAccessUserDetails d ON a.UID = d.UID " +
"WHERE UserName = @UserName " +
" AND Password = @Password AND Deleted = 0 " +
" AND TranTypeID = @TranTypeID AND AllowWrite = 1 AND Enabled =1 ";
cmd.Parameters.AddWithValue("UserName", UserName);
cmd.Parameters.AddWithValue("Password", Password);
cmd.Parameters.AddWithValue("TranTypeID", accesstype.ToString("d"));
cmd.CommandText = SQL;
string strDataTableName = "tbl" + this.GetType().FullName.Split(new Char[] { '.' })[this.GetType().FullName.Split(new Char[] { '.' }).Length - 1]; System.Data.DataTable dt = new System.Data.DataTable(strDataTableName);
base.MySqlDataAdapterFill(cmd, dt);
Int64 iID = 0;
foreach (System.Data.DataRow dr in dt.Rows)
{
iID = Int64.Parse(dr["UID"].ToString());
pstrName = dr["Name"].ToString();
}
return iID;
}
catch (Exception ex)
{
throw base.ThrowException(ex);
}
}
public DialogResult GetWriteAccess(Int64 UID, AccessTypes accesstype)
{
DialogResult resRetValue = DialogResult.None;
AccessRights clsAccessRights = new AccessRights(mConnection, mTransaction);
AccessRightsDetails clsDetails = new AccessRightsDetails();
clsDetails = clsAccessRights.Details(UID, (Int16)accesstype);
if (clsDetails.Write)
{
resRetValue = DialogResult.OK;
}
clsAccessRights.CommitAndDispose();
return resRetValue;
}
public DialogResult GetWriteAccessAndLogin(Int64 UID, AccessTypes AccessType, string OverridingHeader = "")
{
DialogResult loginresult = GetWriteAccess(mclsSalesTransactionDetails.CashierID, AccessType);
if (loginresult == DialogResult.None)
{
string strHeader = OverridingHeader;
if (string.IsNullOrEmpty(strHeader))
{
switch (AccessType)
{
case AccessTypes.PrintTransactionHeader: strHeader = "Print Transaction Header"; break;
case AccessTypes.ChangeQuantity: strHeader = "Change Quantity"; break;
case AccessTypes.ChangePrice: strHeader = "Change Price"; break;
case AccessTypes.ReturnItem: strHeader = "Return Item Access"; break;
case AccessTypes.ApplyItemDiscount: strHeader = "Apply Item Discount"; break;
case AccessTypes.Contacts: strHeader = "Update customer information"; break;
case AccessTypes.SuspendTransaction: strHeader = "Suspend Transaction No. " + mclsSalesTransactionDetails.TransactionNo; break;
case AccessTypes.ResumeTransaction: strHeader = "Resume Suspended Transaction"; break;
case AccessTypes.ResumeSuspendedOpenTransaction: strHeader = "Resume Suspended Open Transaction"; break;
case AccessTypes.VoidTransaction: strHeader = "Void Transaction No. " + mclsSalesTransactionDetails.TransactionNo; break;
case AccessTypes.Withhold: strHeader = "WithHold Amount"; break;
case AccessTypes.Disburse: strHeader = "Disburse Amount"; break;
case AccessTypes.PaidOut: strHeader = "Paid-Out Amount"; break;
case AccessTypes.MallForwarder: strHeader = "Mall Data Forwarder"; break;
case AccessTypes.VoidItem: strHeader = "Void Item"; break;
case AccessTypes.CashCount: strHeader = "Issue Cash Count"; break;
case AccessTypes.EnterFloat: strHeader = "Enter Float or Beginning Balance"; break;
case AccessTypes.InitializeZRead: strHeader = "Initialize Z-Read"; break;
case AccessTypes.CreateTransaction: strHeader = "Create Transaction"; break;
case AccessTypes.CloseTransaction: strHeader = "Close Transaction"; break;
case AccessTypes.ReleaseItems: strHeader = "Release Items"; break;
case AccessTypes.LogoutFE: strHeader = "Logout"; break;
case AccessTypes.ApplyTransDiscount: strHeader = "Apply Transaction Discount"; break;
case AccessTypes.ChargeType: strHeader = "Apply Transaction Charge"; break;
case AccessTypes.OpenDrawer: strHeader = "Open Drawer"; break;
case AccessTypes.CreditPayment: strHeader = "Enter Credit Payment"; break;
case AccessTypes.RefundTransaction: strHeader = "Refund Transaction"; break;
case AccessTypes.RewardCardIssuance: strHeader = "Issue new Reward Card"; break;
case AccessTypes.RewardCardChange: strHeader = "Reward Card Replacement"; break;
case AccessTypes.CreditCardIssuance: strHeader = "Issue new Credit Card"; break;
case AccessTypes.CreditCardChange: strHeader = "Credit Card Replacement"; break;
case AccessTypes.PackUnpackTransaction: strHeader = "Pack/Unpack Transaction Access Validation"; break;
case AccessTypes.ReprintTransaction: strHeader = "Reprint Transaction Access Validation"; break;
case AccessTypes.PrintZRead: strHeader = "Print ZRead Access Validation"; break;
case AccessTypes.PrintXRead: strHeader = "Print XRead Access Validation"; break;
case AccessTypes.PrintHourlyReport: strHeader = "Print Hourly Report Access Validation"; break;
case AccessTypes.PrintGroupReport: strHeader = "Print Group/Dept. Report Access Validation"; break;
case AccessTypes.PrintPLUReport: strHeader = "Print PLU Report Access Validation"; break;
case AccessTypes.PrintElectronicJournal: strHeader = "Print EJournal Report Access Validation"; break;
default: strHeader = AccessType.ToString(); break;
}
}
LogInWnd login = new LogInWnd();
login.AccessType = AccessType;
login.Header = strHeader;
login.TerminalDetails = mclsTerminalDetails;
login.ShowDialog(this);
loginresult = login.Result;
AccessUserDetails clsAccessUserDetails = login.AccessUserDetails;
login.Close();
login.Dispose();
if (loginresult != System.Windows.Forms.DialogResult.OK)
loginresult = System.Windows.Forms.DialogResult.Cancel;
else
{
// 06Jun2015 : do an override event log
if (UID != clsAccessUserDetails.UID)
{
clsEvent.AddEventLn("[Override: " + AccessType.ToString("") + "] " + clsAccessUserDetails.Name + ": " + strHeader, true);
}
}
}
return loginresult;
}
internal static bool DoesTargetTypeMatch(Type baseType, Type memberType, AccessTypes access)
{
if ((access & AccessTypes.ReadWrite) == AccessTypes.ReadWrite)
return TypeProvider.IsRepresentingTheSameType(memberType, baseType);
else if ((access & AccessTypes.Read) == AccessTypes.Read)
return TypeProvider.IsAssignable(baseType, memberType, true);
else if ((access & AccessTypes.Write) == AccessTypes.Write)
return TypeProvider.IsAssignable(memberType, baseType, true);
else
return false;
}
/// <summary>
/// Creates named memory object with given properties.
/// </summary>
protected virtual IntPtr Create(IntPtr handle, ref uint size, ref ulong offset, string name, SectionTypes section, AccessTypes access)
{
ProtectionTypes protection;
switch (access)
{
case AccessTypes.Copy:
protection = ProtectionTypes.PageWriteCopy;
break;
case AccessTypes.ReadOnly:
protection = ProtectionTypes.PageReadOnly;
break;
default:
protection = ProtectionTypes.PageReadWrite;
break;
}
return(CreateFileMapping(handle, 0, (uint)protection | (uint)section, 0, size, name));
}
/// <summary>
/// Uploads a document into Scribd
/// </summary>
/// <param name="stream">A <see cref="Stream"/> to send</param>
/// <param name="accessType">Access permission of document</param>
/// <param name="revisionNumber">The document id to save uploaded file as a revision to</param>
/// <param name="documentType">Type of document</param>
/// <param name="asynch">Indicates whether to upload file asynchronously.</param>
/// <returns><see cref="T:Scribd.Net.Document"/> instance of the uploaded document.</returns>
public static Document Upload(Stream stream, AccessTypes accessType, int revisionNumber, string documentType, bool asynch)
{
Document _result = new Document();
string _fileName = StreamToFile(ref stream);
if (!string.IsNullOrEmpty(_fileName))
{
_result = Document.Upload(_fileName, accessType, revisionNumber, documentType, asynch);
}
else
{
_result= null;
}
try
{
File.Delete(_fileName);
}
catch { }
return _result;
}
/// <summary>
/// Opens specified memory mapped object.
/// </summary>
public void Open(uint size, string name, AccessTypes access)
{
Open(size, name, 0, access);
}
public System.Data.DataTable AdvanceSearch(DateTime ActivityDateFrom, DateTime ActivityDateTo, string User, AccessTypes Activity, string Remarks, int limit = 0, string SortField = "ActivityDate", SortOption SortOrder = SortOption.Ascending)
{
try
{
MySqlCommand cmd = new MySqlCommand();
cmd.CommandType = System.Data.CommandType.Text;
string SQL = SQLSelect() + "WHERE 1=1 ";
if (ActivityDateFrom != DateTime.MinValue)
{
SQL += "AND ActivityDate >= @ActivityDateFrom ";
cmd.Parameters.AddWithValue("@ActivityDateFrom", ActivityDateFrom.ToString("yyyy-MM-dd HH:mm"));
}
if (ActivityDateTo != DateTime.MinValue)
{
SQL += "AND ActivityDate >= @ActivityDateTo ";
cmd.Parameters.AddWithValue("@ActivityDateTo", ActivityDateTo.ToString("yyyy-MM-dd HH:mm"));
}
if (!string.IsNullOrEmpty(User))
{
SQL += "AND User = @User ";
cmd.Parameters.AddWithValue("@User", User);
}
if (Activity != AccessTypes.None)
{
SQL += "AND Activity = @Activity ";
cmd.Parameters.AddWithValue("@Activity", Activity);
}
if (!string.IsNullOrEmpty(Remarks))
{
SQL += "AND Remarks LIKE @Remarks ";
cmd.Parameters.AddWithValue("@Remarks", Remarks);
}
SQL += "ORDER BY " + SortField + " ";
SQL += SortOrder == SortOption.Ascending ? "ASC " : "DESC ";
SQL += limit == 0 ? "" : " LIMIT " + limit.ToString() + " ";
cmd.CommandText = SQL;
string strDataTableName = "tbl" + this.GetType().FullName.Split(new Char[] { '.' })[this.GetType().FullName.Split(new Char[] { '.' }).Length - 1]; System.Data.DataTable dt = new System.Data.DataTable(strDataTableName);
base.MySqlDataAdapterFill(cmd, dt);
return dt;
}
catch (Exception ex)
{
throw base.ThrowException(ex);
}
}
private static extern IntPtr OpenFileMapping(AccessTypes dwDesiredAccess, bool bInheritHandle, string lpName);
/// <summary>
/// Uploads a document into Scribd
/// </summary>
/// <param name="path">Local or Url path to the file</param>
/// <param name="accessType">Access permission of document</param>
/// <param name="revisionNumber">The document id to save uploaded file as a revision to</param>
/// <param name="documentType">Type of document</param>
/// <param name="asynch">Synch of Asych upload?</param>
/// <returns><see cref="T:Scribd.Net.Document"/> instance of the uploaded document.</returns>
public static Document Upload(string path, AccessTypes accessType, int revisionNumber, string documentType, bool asynch)
{
return _Upload(path, accessType, revisionNumber, documentType, false, DownloadAndDRMTypes.Default, asynch);
}
public AuditTrailDetails[] DetailedList(DateTime ActivityDateFrom, DateTime ActivityDateTo, string User, AccessTypes Activity, string Remarks, int limit = 0, string SortField = "ActivityDate", SortOption SortOrder = SortOption.Ascending)
{
try
{
System.Data.DataTable dt = AdvanceSearch(ActivityDateFrom, ActivityDateTo, User, Activity, Remarks, limit, SortField, SortOrder);
ArrayList arrDetails = new ArrayList();
AuditTrailDetails clsDetails = new AuditTrailDetails();
foreach(System.Data.DataRow dr in dt.Rows)
{
clsDetails = new AuditTrailDetails();
clsDetails.ActivityDate = DateTime.Parse(dr["ActivityDate"].ToString());
clsDetails.User = dr["User"].ToString();
clsDetails.Activity = dr["Activity"].ToString();
clsDetails.IPAddress = dr["IPAddress"].ToString();
clsDetails.Remarks = dr["Remarks"].ToString();
clsDetails.CreatedOn = DateTime.Parse(dr["CreatedOn"].ToString());
clsDetails.LastModified = DateTime.Parse(dr["LastModified"].ToString());
arrDetails.Add(clsDetails);
}
AuditTrailDetails[] arrList = new AuditTrailDetails[0];
if (arrDetails != null)
{
arrList = new AuditTrailDetails[arrDetails.Count];
arrDetails.CopyTo(arrList);
}
return arrList;
}
catch (Exception ex)
{
throw base.ThrowException(ex);
}
}
/// <summary>
/// Uploads a document into Scribd
/// </summary>
/// <param name="path">Local or Url path to the file</param>
/// <param name="accessType">Access permission of document</param>
/// <param name="revisionNumber">The document id to save uploaded file as a revision to</param>
/// <param name="documentType">Type of document</param>
/// <param name="downloadType">Download options to support</param>
/// <param name="asynch">Synch of Asych upload?</param>
/// <returns><see cref="T:Scribd.Net.Document"/> instance of the uploaded document.</returns>
public static Document UploadPaidContent(string path, AccessTypes accessType, int revisionNumber,
string documentType, DownloadAndDRMTypes downloadType, bool asynch)
{
return _Upload(path, accessType, revisionNumber, documentType, true, downloadType, asynch);
}
public T OopAccess(AccessTypes enumAccess)
{
OopAccessScript = AccessReverser.GetAccess(enumAccess);
return(Link);
}
/// <summary>
/// Uploads a document into Scribd
/// </summary>
/// <param name="path">Local or Url path to the file</param>
/// <param name="accessType">Access permission of document</param>
/// <param name="revisionNumber">The document id to save uploaded file as a revision to</param>
/// <param name="documentType">Type of document</param>
/// <param name="paidContent">Is this paid content or not</param>
/// <param name="downloadType">Download options to support</param>
/// <param name="asynch">Synch of Asych upload?</param>
/// <returns><see cref="T:Scribd.Net.Document"/> instance of the uploaded document.</returns>
private static Document _Upload(string path, AccessTypes accessType, int revisionNumber, string documentType,
bool paidContent, DownloadAndDRMTypes downloadType, bool asynch)
{
Document _result = new Document();
// Build our request
using (Request _request = new Request())
{
// Is this from a URL?
if (path.StartsWith(@"http://") || path.StartsWith(@"https://"))
{
// Upload to Scribd via URL
_request.MethodName = "docs.uploadFromUrl";
_request.Parameters.Add("url", path);
}
else
{
// Don't.
_request.MethodName = "docs.upload";
_request.Parameters.Add("file", path);
}
if (!string.IsNullOrEmpty(documentType))
{
_request.Parameters.Add("doc_type", documentType.ToLower());
}
_request.Parameters.Add("access", accessType == AccessTypes.Public ? "public" : "private");
if (revisionNumber != 0)
{
_request.Parameters.Add("rev_id", revisionNumber.ToString());
}
if (paidContent)
{
_request.Parameters.Add("paid_content", "1");
if (downloadType != DownloadAndDRMTypes.Default)
{
switch (downloadType)
{
case DownloadAndDRMTypes.DownloadDRM: _request.Parameters.Add("download_and_drm", "download-drm"); break;
case DownloadAndDRMTypes.DownloadPDF: _request.Parameters.Add("download_and_drm", "download-pdf"); break;
case DownloadAndDRMTypes.DownloadPDFandOriginal: _request.Parameters.Add("download_and_drm", "download-pdf-orig"); break;
case DownloadAndDRMTypes.ViewOnly: _request.Parameters.Add("download_and_drm", "view-only"); break;
}
}
}
if (asynch)
{
// Post it asychronously
Service.Instance.PostFileUploadRequest(_request);
}
else
{
// Post is sychronously
// Get our response
Response _response = Service.Instance.PostRequest(_request);
// Parse the response
if (_response != null && _response.HasChildNodes && _response.ErrorList.Count < 1)
{
XmlNode _node = _response.SelectSingleNode("rsp");
// Data
_result.DocumentId = int.Parse(_node.SelectSingleNode("doc_id").InnerText);
_result.AccessKey = _node.SelectSingleNode("access_key").InnerText;
// Security
if (_node.SelectSingleNode("secret_password") != null)
{
_result.AccessType = AccessTypes.Private;
_result.SecretPassword = _node.SelectSingleNode("secret_password").InnerText;
}
}
// Notify subscribers
OnUploaded(_result);
}
}
return _result;
}
