public static void AssemblyInitialize(TestContext context)
{
Ace.Init();
RtpsDiscovery disc = new RtpsDiscovery(RTPS_DISCOVERY);
ParticipantService.Instance.AddDiscovery(disc);
ParticipantService.Instance.DefaultDiscovery = RTPS_DISCOVERY;
Assert.AreEqual(RTPS_DISCOVERY, ParticipantService.Instance.DefaultDiscovery);
ParticipantService.Instance.SetRepoDomain(RTPS_DOMAIN, RTPS_DISCOVERY);
ParticipantService.Instance.SetRepoDomain(RTPS_OTHER_DOMAIN, RTPS_DISCOVERY);
InfoRepoDiscovery infoRepo = new InfoRepoDiscovery(INFOREPO_DISCOVERY, "file://" + INFOREPO_IOR);
ParticipantService.Instance.AddDiscovery(infoRepo);
ParticipantService.Instance.SetRepoDomain(INFOREPO_DOMAIN, INFOREPO_DISCOVERY);
_supportProcess = new SupportProcessHelper(context);
_infoProcess = _supportProcess.SpawnDCPSInfoRepo();
System.Threading.Thread.Sleep(1000);
Factory = ParticipantService.Instance.GetDomainParticipantFactory("-DCPSDebugLevel", "10", "-ORBLogFile", "LogFile.log", "-ORBDebugLevel", "10");
Assert.IsFalse(TransportRegistry.Instance.Released);
Assert.IsFalse(ParticipantService.Instance.IsShutdown);
}
private static void AllowFileAccess(AppContainerProfile container, string folder, FileAccessRights accessRights)
{
var securityInfo = Win32Security.GetSecurityInfo(
folder,
SeObjectType.File,
SecurityInformation.Dacl);
var existingAce = securityInfo.Dacl.FirstOrDefault(d => d.Sid == container.Sid);
if (existingAce is not null &&
existingAce.Type == AceType.Allowed &&
existingAce.Mask == accessRights &&
existingAce.Flags == (AceFlags.ContainerInherit | AceFlags.ObjectInherit))
{
// Ace already exists.
return;
}
var ace = new Ace(
AceType.Allowed,
AceFlags.ContainerInherit | AceFlags.ObjectInherit,
accessRights,
container.Sid);
securityInfo.AddAce(ace);
Win32Security.SetSecurityInfo(
folder,
SeObjectType.File,
SecurityInformation.Dacl,
securityInfo,
true);
}
private void OnApplicationStartup(object sender, StartupEventArgs e)
{
Ace.Init();
InteroperatibilityProvider provider = InteroperatibilityProvider.OpenDDS;
if (e.Args.Length > 0 && e.Args[0].StartsWith("-Vendor="))
{
string strProvider = e.Args[0].Replace("-Vendor=", string.Empty);
switch (strProvider.ToLower())
{
case "rti":
provider = InteroperatibilityProvider.Rti;
break;
case "opensplice":
provider = InteroperatibilityProvider.OpenSplice;
break;
default:
provider = InteroperatibilityProvider.OpenDDS;
break;
}
}
ViewModelLocator.Provider = provider;
}
/// <summary>
/// Evaluates whether the DACL fulfills the given AdRoleAssertion and returns the list of unsatisfied AceAssertions
/// (if any).
/// If the assertor was constructed with {@code searchGroups = true} and the roleAssertion specifies a user,
/// then
/// all group SIDs contained in the roleAssertion will be tested for potential matches in the DACL if any
/// rights are
/// not directly granted to the user. Also, the 'Everyone' AD group will also be scanned.
/// Denied rights are now detected and included in the resulting list.
/// @param roleAssertion
/// the AdRoleAssertion to test
/// @return List of unsatisfied AceAssertions (if any). Empty if none.
/// </summary>
private List <AceAssertion> FindUnsatisfiedAssertions(AdRoleAssertion roleAssertion)
{
var acesBySIDMap = new Dictionary <string, List <Ace> >();
for (var i = 0; i < this.dacl.GetAceCount(); i++)
{
Ace ace = this.dacl.GetAce(i);
if (ace.GetSid() != null)
{
if (!acesBySIDMap.ContainsKey(ace.GetSid().ToString()))
{
acesBySIDMap.Add(ace.GetSid().ToString(), new List <Ace>());
}
acesBySIDMap[ace.GetSid().ToString()].Add(ace);
}
}
// Find any roleAssertion ACEs not matched in the DACL.
// Not using Java 8 or other libs for this to keep dependencies of ADSDDL as is.
// ------------------------------
var unsatisfiedAssertions = new List <AceAssertion>(roleAssertion.GetAssertions());
var deniedAssertions = new List <AceAssertion>();
SID principal = roleAssertion.GetPrincipal();
if (acesBySIDMap.ContainsKey(principal.ToString()))
{
this.FindUnmatchedAssertions(acesBySIDMap[principal.ToString()], unsatisfiedAssertions, deniedAssertions, roleAssertion.GetAssertions());
}
// There may be denials on groups even if we resolved all assertions - search groups if specified
if (this.searchGroups)
{
if (roleAssertion.IsGroup())
{
this.DoEveryoneGroupScan(acesBySIDMap, unsatisfiedAssertions, deniedAssertions, roleAssertion.GetAssertions());
this.MergeDenials(unsatisfiedAssertions, deniedAssertions);
return(unsatisfiedAssertions);
}
List <SID> tokenGroupSiDs = roleAssertion.GetTokenGroups();
if (tokenGroupSiDs == null)
{
this.DoEveryoneGroupScan(acesBySIDMap, unsatisfiedAssertions, deniedAssertions, roleAssertion.GetAssertions());
this.MergeDenials(unsatisfiedAssertions, deniedAssertions);
return(unsatisfiedAssertions);
}
foreach (SID grpSID in tokenGroupSiDs.Where(grpSID => acesBySIDMap.ContainsKey(grpSID.ToString())))
{
this.FindUnmatchedAssertions(acesBySIDMap[grpSID.ToString()], unsatisfiedAssertions, deniedAssertions, roleAssertion.GetAssertions());
}
this.DoEveryoneGroupScan(acesBySIDMap, unsatisfiedAssertions, deniedAssertions, roleAssertion.GetAssertions());
}
this.MergeDenials(unsatisfiedAssertions, deniedAssertions);
return(unsatisfiedAssertions);
}
/// <summary>
/// Check if user canot change password.
/// @param sddl SSDL.
/// @return <tt>true</tt> if user cannot change password: <tt>false</tt> otherwise.
/// </summary>
public static bool IsUserCannotChangePassword(Sddl sddl)
{
var res = false;
List <Ace> aces = sddl.GetDacl().GetAces();
for (var i = 0; !res && i < aces.Count; i++)
{
Ace ace = aces[i];
if (ace.GetAceType() == AceType.AccessDeniedObjectAceType &&
ace.GetObjectFlags().GetFlags().Contains(AceObjectFlags.Flag.AceObjectTypePresent))
{
if (ace.GetObjectType() == ucpObjectGuid)
{
SID sid = ace.GetSid();
if (sid.GetSubAuthorities().Count == 1)
{
if (sid.GetIdentifierAuthority().SequenceEqual(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 }) &&
sid.GetSubAuthorities().First().SequenceEqual(new byte[] { 0x00, 0x00, 0x00, 0x00 }) ||
sid.GetIdentifierAuthority().SequenceEqual(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x05 }) &&
sid.GetSubAuthorities().First().SequenceEqual(new byte[] { 0x00, 0x00, 0x00, 0x0a }))
{
res = true;
}
}
}
}
}
return(res);
}
internal SecurityDescriptorInheritanceSource(
Ace ace, INHERITED_FROM inherited_from, SeObjectType type,
NtType native_type,
bool container,
bool query_security, bool sacl)
{
InheritedAce = ace;
if (native_type != null)
{
Access = NtSecurity.AccessMaskToString(ace.Mask, container
? native_type.ContainerAccessRightsType
: native_type.AccessRightsType,
native_type.GenericMapping, false);
GenericAccess = NtSecurity.AccessMaskToString(ace.Mask, container
? native_type.ContainerAccessRightsType
: native_type.AccessRightsType,
native_type.GenericMapping, true);
}
else
{
Access = NtSecurity.AccessMaskToString(ace.Mask.ToGenericAccess());
GenericAccess = NtSecurity.AccessMaskToString(ace.Mask.ToGenericAccess());
}
Depth = inherited_from.GenerationGap;
Name = Marshal.PtrToStringUni(inherited_from.AncestorName);
if (query_security && Name != null)
{
SecurityInformation sec_info = sacl ? SecurityInformation.All : SecurityInformation.AllNoSacl;
var sd = Win32Security.GetSecurityInfo(Name, type, sec_info, false);
if (sd.IsSuccess)
{
SecurityDescriptor = sd.Result;
}
}
}
private bool CheckSid(Sid sid, Ace ace)
{
if (sid != null && ace.Sid != sid)
{
return(false);
}
if (Type.HasValue && ace.Type != Type)
{
return(false);
}
if (Access.HasValue && ace.Mask != Access)
{
return(false);
}
if (Flags.HasValue)
{
if (AllFlags)
{
if (ace.Flags != Flags)
{
return(false);
}
}
else
{
if ((ace.Flags & Flags) != Flags)
{
return(false);
}
}
}
return(true);
}
public static void AssemblyInitialize(TestContext context)
{
Ace.Init();
RtpsDiscovery disc = new RtpsDiscovery(RTPS_DISCOVERY);
Assert.AreEqual(RTPS_DISCOVERY, disc.Key);
ParticipantService.Instance.AddDiscovery(disc);
ParticipantService.Instance.DefaultDiscovery = RTPS_DISCOVERY;
Assert.AreEqual(RTPS_DISCOVERY, ParticipantService.Instance.DefaultDiscovery);
ParticipantService.Instance.SetRepoDomain(RTPS_DOMAIN, RTPS_DISCOVERY);
ParticipantService.Instance.SetRepoDomain(RTPS_OTHER_DOMAIN, RTPS_DISCOVERY);
InfoRepoDiscovery infoRepo = new InfoRepoDiscovery(INFOREPO_DISCOVERY, "corbaloc::localhost:12345/DCPSInfoRepo");
ParticipantService.Instance.AddDiscovery(infoRepo);
infoRepo.BitTransportIp = "localhost";
infoRepo.BitTransportPort = 0;
ParticipantService.Instance.SetRepoDomain(INFOREPO_DOMAIN, INFOREPO_DISCOVERY);
_supportProcess = new SupportProcessHelper(context);
_infoProcess = _supportProcess.SpawnDCPSInfoRepo();
System.Threading.Thread.Sleep(1000);
Factory = ParticipantService.Instance.GetDomainParticipantFactory();
Assert.IsFalse(TransportRegistry.Instance.Released);
Assert.IsFalse(ParticipantService.Instance.IsShutdown);
}
private void listViewAcl_SelectedIndexChanged(object sender, EventArgs e)
{
Ace ace = GetSelectedAce();
if (ace == null)
{
return;
}
Type access_type = _access_type;
AccessMask valid_access = _valid_access;
AccessMask mapped_mask = _mapping.MapMask(ace.Mask) & _valid_access;
bool generic_access_mask = false;
if (ace.Type == AceType.MandatoryLabel)
{
mapped_mask = ace.Mask;
access_type = typeof(MandatoryLabelPolicy);
valid_access = 0x7;
}
else if (ace.Flags.HasFlag(AceFlags.InheritOnly))
{
mapped_mask = ace.Mask;
generic_access_mask = true;
valid_access = valid_access
| GenericAccessRights.GenericRead
| GenericAccessRights.GenericWrite
| GenericAccessRights.GenericExecute
| GenericAccessRights.GenericAll;
}
if (access_type != _current_access_type || generic_access_mask != _generic_access_mask)
{
_generic_access_mask = generic_access_mask;
_current_access_type = access_type;
var masks = Win32Utils.GetMaskDictionary(access_type, valid_access, _sdk_names);
var ordered = generic_access_mask ? masks.OrderByDescending(p => p.Key) : masks.OrderBy(p => p.Key);
ListViewItem[] items = ordered.Select(pair =>
{
ListViewItem item = new ListViewItem(pair.Value);
item.SubItems.Add($"0x{pair.Key:X08}");
item.Tag = pair.Key;
return(item);
}
).ToArray();
listViewAccess.Items.Clear();
listViewAccess.Items.AddRange(items);
listViewAccess.AutoResizeColumns(ColumnHeaderAutoResizeStyle.ColumnContent);
listViewAccess.AutoResizeColumns(ColumnHeaderAutoResizeStyle.HeaderSize);
}
_read_only_checks = false;
foreach (ListViewItem item in listViewAccess.Items)
{
uint mask = (uint)item.Tag;
item.Checked = (mapped_mask & mask) != 0;
}
_read_only_checks = true;
}
public AceToAcmeAdapter(Ace ace)
{
this.ace = ace;
Char space = Convert.ToChar(" ");
firstName = ace.GetName().Split(space)[0];
lastName = ace.GetName().Split(space)[1];
}
private void contextMenuStripAcl_Opening(object sender, System.ComponentModel.CancelEventArgs e)
{
Ace ace = GetSelectedAce();
bool selected = ace != null;
copySIDToolStripMenuItem.Enabled = selected;
copyAccountToolStripMenuItem.Enabled = selected;
copyConditionToolStripMenuItem.Enabled = selected && ace.IsConditionalAce;
}
public SystemData(StudioController game)
{
// export a dict contains all system status
//from Studio import Studio
//studio = Studio.Instance
bgm = new BGM_s {
no = game.studio.bgmCtrl.no, play = game.studio.bgmCtrl.play
};
if (game.studio.outsideSoundCtrl.fileName != "")
{
wav = new Wav_s {
fileName = game.studio.outsideSoundCtrl.fileName, play = game.studio.outsideSoundCtrl.play, repeat = game.studio.outsideSoundCtrl.repeat == BGMCtrl.Repeat.All
};
}
else
{
wav = null;
}
map = game.studio_scene.map;
map_pos = game.studio_scene.caMap.pos;
map_rot = game.studio_scene.caMap.rot;
sun = game.studio_scene.sunLightType;
map_opt = game.studio_scene.mapOption;
bg_png = game.scene_get_bg_png_orig();
fm_png = game.scene_get_framefile();
var cl = game.studio_scene.charaLight;
char_light = new CharLight_s {
rgbDiffuse = cl.color, cameraLightIntensity = cl.intensity, rot_y = cl.rot[0], rot_x = cl.rot[1], cameraLightShadow = cl.shadow
};
ace = System.ace;
/* TODO
* if (game.isStudioNEO || game.isCharaStudio)
* {
* if (extplugins.ExtPlugin.exists("NodesConstraints"))
* {
* if (is_ini_value_true("ExportSys_NodesConstraints"))
* {
* var pl_nodescon = extplugins.NodesConstraints();
* pl_nodescon = pl_nodescon.GetSysSettingsText();
* }
* }
* }
*/
}
void OnTriggerEnter2D(Collider2D hitInfo)
{
Ace enemy = hitInfo.GetComponent <Ace>();
if (enemy != null)
{
Destroy(gameObject);
enemy.TakeDamage(damage);
}
}
private void copyAccountToolStripMenuItem_Click(object sender, EventArgs e)
{
Ace ace = GetSelectedAce();
if (ace == null)
{
return;
}
CopyToClipboard(ace.Sid.Name);
}
public Program()
{
Ace ace = new Ace();
ace.SetName("Cary Grant");
AceToAcmeAdapter acmeAdapter = new AceToAcmeAdapter(ace);
Console.WriteLine("First Name : {0}", acmeAdapter.GetFirstName());
Console.WriteLine("Last Name : {0}", acmeAdapter.GetLastName());
}
private void copyConditionToolStripMenuItem_Click(object sender, EventArgs e)
{
Ace ace = GetSelectedAce();
if (ace == null)
{
return;
}
if (ace.IsConditionalAce)
{
CopyToClipboard(ace.Condition);
}
}
public IAce CreateAce(string principal, IList <string> permissions)
{
Ace ace = new Ace();
ace.IsDirect = true;
Principal acePrincipal = new Principal();
acePrincipal.Id = principal;
ace.Principal = acePrincipal;
ace.Permissions = permissions;
return(ace);
}
private bool HandleCallbackAce(
IntPtr hAuthzClientContext,
IntPtr pAce,
IntPtr pArgs,
out bool pbAceApplicable)
{
pbAceApplicable = false;
try {
pbAceApplicable = _handle_callback_ace(Ace.Parse(pAce));
return(true);
} catch {
return(false);
}
}
public void Update(Ace ace)
{
var aceDs = Utility.TflWs.GetAce(ace.Season, ace.Week, ace.PlayerId);
if (aceDs.Tables[0].Rows.Count == 1)
{
// if yes just update
Utility.TflWs.UpdateAce(ace.Season, ace.Week, ace.PlayerId, ace.PlayerCat, ace.TeamCode,
ace.Load, ace.Touches);
}
else
{
Add(ace);
}
}
public void TestAcl()
{
IDocument doc = null;
try
{
doc = CreateTextDocument(Session.GetRootFolder(), "acl.txt", "Hello Joe!");
Ace joeAce = new Ace()
{
Principal = new Principal()
{
Id = "joe"
},
Permissions = new List <string> {
"cmis:write"
}
};
// apply ACL and test result
IAcl newAcl = doc.ApplyAcl(new List <IAce> {
joeAce
}, null, AclPropagation.RepositoryDetermined);
Assert.IsNotNull(newAcl);
Assert.IsNotNull(newAcl.Aces);
Assert.IsTrue(newAcl.Aces.Count > 0);
// retrieve ACL and test
IAcl acl2 = Session.GetAcl(doc, true);
Assert.IsNotNull(acl2);
Assert.IsNotNull(acl2.Aces);
Assert.IsTrue(acl2.Aces.Count > 0);
// fetch document and test
IDocument doc2 = (IDocument)Session.GetObject(doc, OperationContextUtils.CreateMaximumOperationContext());
Assert.IsNotNull(doc2.Acl);
Assert.IsNotNull(doc2.Acl.Aces);
Assert.IsTrue(doc2.Acl.Aces.Count > 0);
}
finally
{
if (doc != null)
{
doc.Delete();
Assert.IsFalse(Session.Exists(doc));
}
}
}
public static void AssemblyCleanup()
{
_supportProcess.KillProcess(_infoProcess);
if (File.Exists(INFOREPO_IOR))
{
File.Delete(INFOREPO_IOR);
}
TransportRegistry.Instance.Release();
Assert.IsTrue(TransportRegistry.Instance.Released);
TransportRegistry.Close();
ParticipantService.Instance.Shutdown();
Assert.IsTrue(ParticipantService.Instance.IsShutdown);
Ace.Fini();
}
private bool ProcessAce(List <Ace> list, Ace ace, bool dacl, Func <Ace, bool> filter)
{
if (!filter(ace))
{
return(false);
}
if (!ShouldProcess($"Type:{ace.Type} Sid:{ace.Sid} Mask:{ace.Mask:X08} in {(dacl ? "DACL" : "SACL")}"))
{
return(false);
}
list.Add(ace);
return(true);
}
/// <summary>
/// Set the security descriptor for the control.
/// </summary>
/// <param name="security_descriptor">Security descriptor to view.</param>
/// <param name="access_type">The enum type for the view.</param>
/// <param name="mapping">Generic mapping for the type.</param>
/// <param name="valid_access">The valid bit mask for access for this type.</param>
/// <param name="is_container">True to indicate this object is a container.</param>
public void SetSecurityDescriptor(SecurityDescriptor security_descriptor, Type access_type, GenericMapping mapping, AccessMask valid_access, bool is_container)
{
AddAclTab(tabPageDACL, aclViewerControlDacl, security_descriptor.Dacl, access_type, mapping, valid_access, is_container);
AddAclTab(tabPageSACL, aclViewerControlSacl, security_descriptor.Sacl, access_type, mapping, valid_access, is_container);
SetSidLabel(lblOwnerValue, security_descriptor.Owner);
SetSidLabel(lblGroupValue, security_descriptor.Group);
Ace label = security_descriptor.GetMandatoryLabel();
if (label != null)
{
lblIntegrityValue.Text = $"{NtSecurity.GetIntegrityLevel(label.Sid)} ({label.Mask.ToMandatoryLabelPolicy()})";
}
else
{
lblIntegrityValue.Text = "N/A";
}
}
private void listViewAcl_SelectedIndexChanged(object sender, EventArgs e)
{
Ace ace = GetSelectedAce();
if (ace == null)
{
return;
}
Type access_type = _access_type;
AccessMask valid_access = _valid_access;
AccessMask mapped_mask = _mapping.MapMask(ace.Mask) & _valid_access;
if (ace.Type == AceType.MandatoryLabel)
{
mapped_mask = ace.Mask;
access_type = typeof(MandatoryLabelPolicy);
valid_access = 0x7;
}
if (access_type != _current_access_type)
{
_current_access_type = access_type;
ListViewItem[] items = Win32Utils.GetMaskDictionary(access_type, valid_access).Select(pair =>
{
ListViewItem item = new ListViewItem(pair.Value);
item.SubItems.Add($"0x{pair.Key:X08}");
item.Tag = pair.Key;
return(item);
}
).ToArray();
listViewAccess.Items.Clear();
listViewAccess.Items.AddRange(items);
listViewAccess.AutoResizeColumns(ColumnHeaderAutoResizeStyle.ColumnContent);
listViewAccess.AutoResizeColumns(ColumnHeaderAutoResizeStyle.HeaderSize);
}
_read_only_checks = false;
foreach (ListViewItem item in listViewAccess.Items)
{
uint mask = (uint)item.Tag;
item.Checked = (mapped_mask & mask) != 0;
}
_read_only_checks = true;
}
/// <summary>
/// Process Record.
/// </summary>
protected override void ProcessRecord()
{
IEnumerable <Ace> aces = new Ace[0];
if (ParameterSetName == "FromAce")
{
aces = FilterFromAce();
}
else
{
aces = SelectAces(RemoveAces);
}
if (PassThru)
{
WriteObject(aces, true);
}
}
private void copyACESDDLToolStripMenuItem_Click(object sender, EventArgs e)
{
Ace ace = GetSelectedAce();
if (ace == null)
{
return;
}
SecurityDescriptor sd = new SecurityDescriptor
{
Dacl = new Acl()
{
ace
}
};
// Copy and remove the DACL prefix.
CopyToClipboard(sd.ToSddl().Substring(2));
}
static void Main(string[] args)
{
Ace.Init();
DomainParticipantFactory dpf = ParticipantService.Instance.GetDomainParticipantFactory("-DCPSConfigFile", "rtps.ini");
DomainParticipant participant = dpf.CreateParticipant(42);
if (participant == null)
{
throw new Exception("Could not create the participant");
}
// Include your program here
participant.DeleteContainedEntities();
dpf.DeleteParticipant(participant);
ParticipantService.Instance.Shutdown();
Ace.Fini();
}
static void Main(string[] args)
{
bool isPublisher = true;
if (args != null && args.Length > 0)
{
isPublisher = !args[0].ToLowerInvariant().Equals("--sub") && !args[0].ToLowerInvariant().Equals("--subscriber");
}
Ace.Init();
DomainParticipantFactory dpf = ParticipantService.Instance.GetDomainParticipantFactory("-DCPSConfigFile", "rtps.ini", "-DCPSDebugLevel", "10", "-ORBLogFile", "LogFile.log", "-ORBDebugLevel", "10");
if (dpf == null)
{
throw new ApplicationException("Domain participant factory could not be created.");
}
DomainParticipant participant = dpf.CreateParticipant(42);
if (dpf == null)
{
throw new ApplicationException("Domain participant could not be created.");
}
if (isPublisher)
{
TestPublisher(participant);
}
else
{
TestSubscriber(participant);
}
Console.WriteLine("Shutting down... that's enough for today.");
participant.DeleteContainedEntities();
dpf.DeleteParticipant(participant);
ParticipantService.Instance.Shutdown();
Ace.Fini();
}
private void AddAceLine(NFLPlayer p, IAceRepository ar)
{
var dline = p.DetailLine();
if (!string.IsNullOrEmpty(dline))
{
Aces.Add(dline);
}
var ace = new Ace
{
PlayerId = p.PlayerCode,
TeamCode = p.TeamCode,
Season = Utility.CurrentSeason(),
Week = Utility.PreviousWeek().ToString(CultureInfo.InvariantCulture),
PlayerCat = p.PlayerCat,
Touches = p.TotStats.Touches,
Load = p.TotStats.TouchLoad,
};
ar.Update(ace);
}
/// <summary>
/// Process Record.
/// </summary>
protected override void ProcessRecord()
{
IEnumerable <Ace> aces = new Ace[0];
switch (ParameterSetName)
{
case "FromSid":
aces = FilterFromSid();
break;
case "FromFilter":
aces = FilterFromFilter();
break;
case "FromAce":
aces = FilterFromAce();
break;
}
if (PassThru)
{
WriteObject(aces, true);
}
}
public static Ace CreateAce(string trustee, string action, long aclId, long ID, string tid, string name, string createdBy, string modifiedBy, global::System.DateTimeOffset created, global::System.DateTimeOffset modified)
{
Ace ace = new Ace();
ace.Trustee = trustee;
ace.Action = action;
ace.AclId = aclId;
ace.Id = ID;
ace.Tid = tid;
ace.Name = name;
ace.CreatedBy = createdBy;
ace.ModifiedBy = modifiedBy;
ace.Created = created;
ace.Modified = modified;
return ace;
}
public static Ace CreateAce(long trusteeId, long trusteeType, long type, long permissionId, long aclId, long ID, global::System.Guid tid, string name, long createdById, long modifiedById, global::System.DateTimeOffset created, global::System.DateTimeOffset modified)
{
Ace ace = new Ace();
ace.TrusteeId = trusteeId;
ace.TrusteeType = trusteeType;
ace.Type = type;
ace.PermissionId = permissionId;
ace.AclId = aclId;
ace.Id = ID;
ace.Tid = tid;
ace.Name = name;
ace.CreatedById = createdById;
ace.ModifiedById = modifiedById;
ace.Created = created;
ace.Modified = modified;
return ace;
}
public void AddToAces(Ace ace)
{
base.AddObject("Aces", ace);
}