function stringlengths 87 5.09k | validationType stringclasses 2 values | fixed stringlengths 289 7.12k |
|---|---|---|
public boolean resolveBundles(Collection<method*start>java.util.Collection<method*end><Bundle<method*start>org.osgi.framework.Bundle<method*end>> bundles) {
Object<method*start>java.lang.Object<method*end> sm = System.getSecurityManager<method*start>java.lang.System.getSecurityManager<method*end>();
((SecurityManager<method*start>java.lang.SecurityManager<method*end>)
if (m_thread == null) {
return false;
}
return m_felix.resolveBundles<method*start>org.apache.felix.framework.Felix.resolveBundles<method*end>(bundles);
}
| conventional | public boolean resolveBundles(Collection<method*start>java.util.Collection<method*end><Bundle<method*start>org.osgi.framework.Bundle<method*end>> bundles) {
Object<method*start>java.lang.Object<method*end> sm = System.getSecurityManager<method*start>java.lang.System.getSecurityManager<method*end>();
if (sm != null) {
((SecurityManager<method*start>java.lang.SecurityManager<method*end>) sm).checkPermission<method*start>java.lang.SecurityManager.checkPermission<method*end>(new AdminPermission<method*start>org.osgi.framework.AdminPermission<method*end>(m_felix, AdminPermission.RESOLVE<method*start>org.osgi.framework.AdminPermission.RESOLVE<method*end>));
}
if (m_thread == null) {
return false;
}
return m_felix.resolveBundles<method*start>org.apache.felix.framework.Felix.resolveBundles<method*end>(bundles);
}
|
public boolean isPermitted() {
String<method*start>java.lang.String<method*end> perm = getUserData<method*start>org.microg.gms.auth.AuthManager.getUserData<method*end>(buildPermKey());
return false;
}
| conventional | public boolean isPermitted() {
if (!service.startsWith<method*start>java.lang.String.startsWith<method*end>("oauth")) {
if (context.getPackageManager<method*start>android.content.Context.getPackageManager<method*end>().checkPermission<method*start>android.content.pm.PackageManager.checkPermission<method*end>(PERMISSION_TREE_BASE + service, packageName) == PackageManager.PERMISSION_GRANTED<method*start>android.content.pm.PackageManager.PERMISSION_GRANTED<method*end>) {
return true;
}
}
String<method*start>java.lang.String<method*end> perm = getUserData<method*start>org.microg.gms.auth.AuthManager.getUserData<method*end>(buildPermKey());
if (!"1".equals<method*start>java.lang.String.equals<method*end>(perm)) {
return false;
}
return true;
}
|
public boolean checkTopLevelWindow(Object<method*start>java.lang.Object<method*end> window) {
if (window == null) {
throw new NullPointerException<method*start>java.lang.NullPointerException<method*end>("window can't be null");
}
return false;
} | conventional | public boolean checkTopLevelWindow(Object<method*start>java.lang.Object<method*end> window) {
if (window == null) {
throw new NullPointerException<method*start>java.lang.NullPointerException<method*end>("window can't be null");
}
try {
checkPermission<method*start>java.lang.SecurityManager.checkPermission<method*end>(SecurityConstants.AWT.TOPLEVEL_WINDOW_PERMISSION<method*start>sun.security.util.SecurityConstants.AWT.TOPLEVEL_WINDOW_PERMISSION<method*end>);
return true;
} catch (SecurityException se) {
// just return false
}
return false;
}
|
public boolean checkTopLevelWindow(Object window) {
if (window == null)
throw new NullPointerException();
try
{
return true;
}
catch (SecurityException e)
{
return false;
}throw new
RuntimeException<method*start>java.lang.RuntimeException<method*end>("Not implemented");
} | conventional | public boolean checkTopLevelWindow(Object window) {
throw new RuntimeException<method*start>java.lang.RuntimeException<method*end>("Not implemented");
/*
if (window == null)
throw new NullPointerException();
try
{
checkPermission(new AWTPermission("showWindowWithoutWarningBanner"));
return true;
}
catch (SecurityException e)
{
return false;
}
*/
}
|
@Override
public AccessControlPolicy[] getPolicies(String absPath) throws PathNotFoundException, AccessDeniedException, RepositoryException {
checkInitialized();
AccessControlPolicy[] policies;
if (editor != null) {
policies = editor.getPolicies(absPath);
} else {
policies = new AccessControlPolicy[0];
}
return policies;
} | annotation | @Override<method*start>java.lang.Override<method*end>
public AccessControlPolicy<method*start>javax.jcr.security.AccessControlPolicy<method*end>[] getPolicies(String<method*start>java.lang.String<method*end> absPath) throws PathNotFoundException<method*start>javax.jcr.PathNotFoundException<method*end>, AccessDeniedException<method*start>javax.jcr.AccessDeniedException<method*end>, RepositoryException<method*start>javax.jcr.RepositoryException<method*end> {
checkInitialized<method*start>org.apache.jackrabbit.core.security.DefaultAccessManager.checkInitialized<method*end>();
checkPermission(absPath, Permission.READ_AC<method*start>org.apache.jackrabbit.core.security.authorization.Permission.READ_AC<method*end>);
AccessControlPolicy<method*start>javax.jcr.security.AccessControlPolicy<method*end>[] policies;
if (editor != null) {
policies = editor.getPolicies<method*start>org.apache.jackrabbit.core.security.authorization.AccessControlEditor.getPolicies<method*end>(absPath);
} else {
policies = new AccessControlPolicy<method*start>javax.jcr.security.AccessControlPolicy<method*end>[0];
}
return policies;
}
|
boolean checkConfig() {
boolean b = checkEntity<method*start>com.arialyy.aria.core.common.controller.FeatureController.checkEntity<method*end>();
TaskSchedulers<method*start>com.arialyy.aria.core.scheduler.TaskSchedulers<method*end> schedulers = TaskSchedulers.getInstance<method*start>com.arialyy.aria.core.scheduler.TaskSchedulers.getInstance<method*end>();
new Handler<method*start>android.os.Handler<method*end>(Looper.getMainLooper<method*start>android.os.Looper.getMainLooper<method*end>(), schedulers).obtainMessage<method*start>android.os.Handler.obtainMessage<method*end>(ISchedulers.CHECK_FAIL<method*start>com.arialyy.aria.core.listener.ISchedulers.CHECK_FAIL<method*end>, checkTaskType(), -1, null).sendToTarget<method*start>android.os.Handler.sendToTarget<method*end>();
}
return b;
} | annotation | boolean checkConfig() {
if (!ignoreCheckPermissions<method*start>com.arialyy.aria.core.common.controller.FeatureController.ignoreCheckPermissions<method*end> && !checkPermission<method*start>com.arialyy.aria.core.common.controller.FeatureController.checkPermission<method*end>()) {
return false;
}
boolean b = checkEntity<method*start>com.arialyy.aria.core.common.controller.FeatureController.checkEntity<method*end>();
TaskSchedulers<method*start>com.arialyy.aria.core.scheduler.TaskSchedulers<method*end> schedulers = TaskSchedulers.getInstance<method*start>com.arialyy.aria.core.scheduler.TaskSchedulers.getInstance<method*end>();
if (!b && schedulers != null) {
new Handler<method*start>android.os.Handler<method*end>(Looper.getMainLooper<method*start>android.os.Looper.getMainLooper<method*end>(), schedulers).obtainMessage<method*start>android.os.Handler.obtainMessage<method*end>(ISchedulers.CHECK_FAIL<method*start>com.arialyy.aria.core.listener.ISchedulers.CHECK_FAIL<method*end>, checkTaskType(), -1, null).sendToTarget<method*start>android.os.Handler.sendToTarget<method*end>();
}
return b;
}
|
public Coordination<method*start>org.osgi.service.coordinator.Coordination<method*end> getCoordination(final long id) {
Coordination<method*start>org.osgi.service.coordinator.Coordination<method*end> c = mgr.getCoordinationById<method*start>org.apache.felix.coordinator.impl.CoordinationMgr.getCoordinationById<method*end>(id);
if (c != null) {
try {
c = ((CoordinationImpl) c).getHolder<method*start>org.apache.felix.coordinator.impl.CoordinationImpl.getHolder<method*end>();
} catch (final SecurityException<method*start>java.lang.SecurityException<method*end> e) {
c = null;
}
}
return c;
} | conventional | public Coordination<method*start>org.osgi.service.coordinator.Coordination<method*end> getCoordination(final long id) {
Coordination<method*start>org.osgi.service.coordinator.Coordination<method*end> c = mgr.getCoordinationById<method*start>org.apache.felix.coordinator.impl.CoordinationMgr.getCoordinationById<method*end>(id);
if (c != null) {
try {
checkPermission(c.getName<method*start>org.osgi.service.coordinator.Coordination.getName<method*end>(), CoordinationPermission.ADMIN<method*start>org.osgi.service.coordinator.CoordinationPermission.ADMIN<method*end>);
c = ((CoordinationImpl) c).getHolder<method*start>org.apache.felix.coordinator.impl.CoordinationImpl.getHolder<method*end>();
} catch (final SecurityException<method*start>java.lang.SecurityException<method*end> e) {
c = null;
}
}
return c;
}
|
public void setEncoding(String encoding) throws SecurityException, java.io.UnsupportedEncodingException {
if (encoding != null) {
try {
if (!java.nio.charset.Charset.isSupported(encoding)) {
throw new UnsupportedEncodingException(encoding);
}
} catch (java.nio.charset.IllegalCharsetNameException e) {
throw new UnsupportedEncodingException(encoding);
}
}
this.encoding = encoding;
} | conventional | public void setEncoding(String<method*start>java.lang.String<method*end> encoding) throws SecurityException<method*start>java.lang.SecurityException<method*end>, java.io.UnsupportedEncodingException<method*start>java.io.UnsupportedEncodingException<method*end> {
checkPermission<method*start>java.util.logging.Handler.checkPermission<method*end>();
if (encoding != null) {
try {
if (!java.nio.charset.Charset.isSupported<method*start>java.nio.charset.Charset.isSupported<method*end>(encoding)) {
throw new UnsupportedEncodingException<method*start>java.io.UnsupportedEncodingException<method*end>(encoding);
}
} catch (java.nio.charset.IllegalCharsetNameException<method*start>java.nio.charset.IllegalCharsetNameException<method*end> e) {
throw new UnsupportedEncodingException<method*start>java.io.UnsupportedEncodingException<method*end>(encoding);
}
}
this.encoding<method*start>java.util.logging.Handler.encoding<method*end> = encoding;
}
|
public static Result<method*start>io.nuls.contract.vm.Result<method*end> override(MethodCode<method*start>io.nuls.contract.vm.code.MethodCode<method*end> methodCode, MethodArgs<method*start>io.nuls.contract.vm.MethodArgs<method*end> methodArgs, Frame<method*start>io.nuls.contract.vm.Frame<method*end> frame, boolean check) {
switch(methodCode.fullName<method*start>io.nuls.contract.vm.code.MethodCode.fullName<method*end>) {
case getRootGroup<method*start>io.nuls.contract.vm.natives.java.lang.NativeSecurityManager.getRootGroup<method*end>:
return getRootGroup<method*start>io.nuls.contract.vm.natives.java.lang.NativeSecurityManager.getRootGroup<method*end>(methodCode, methodArgs, frame);
}
case checkAccessThread<method*start>io.nuls.contract.vm.natives.java.lang.NativeSecurityManager.checkAccessThread<method*end>:
if (check) {
return SUPPORT_NATIVE<method*start>io.nuls.contract.vm.natives.NativeMethod.SUPPORT_NATIVE<method*end>;
} else {
return checkAccessThread<method*start>io.nuls.contract.vm.natives.java.lang.NativeSecurityManager.checkAccessThread<method*end>(methodCode, methodArgs, frame);
}
case checkAccess<method*start>io.nuls.contract.vm.natives.java.lang.NativeSecurityManager.checkAccess<method*end>:
if (check) {
return SUPPORT_NATIVE<method*start>io.nuls.contract.vm.natives.NativeMethod.SUPPORT_NATIVE<method*end>;
} else {
return checkAccess<method*start>io.nuls.contract.vm.natives.java.lang.NativeSecurityManager.checkAccess<method*end>(methodCode, methodArgs, frame);
}
case checkPropertyAccess<method*start>io.nuls.contract.vm.natives.java.lang.NativeSecurityManager.checkPropertyAccess<method*end>:
if (check) {
return SUPPORT_NATIVE<method*start>io.nuls.contract.vm.natives.NativeMethod.SUPPORT_NATIVE<method*end>;
} else {
return checkPropertyAccess<method*start>io.nuls.contract.vm.natives.java.lang.NativeSecurityManager.checkPropertyAccess<method*end>(methodCode, methodArgs, frame);
}
case checkPermission<method*start>io.nuls.contract.vm.natives.java.lang.NativeSecurityManager.checkPermission<method*end>:
if (check) {
return SUPPORT_NATIVE<method*start>io.nuls.contract.vm.natives.NativeMethod.SUPPORT_NATIVE<method*end>;
} else {
return checkPermission<method*start>io.nuls.contract.vm.natives.java.lang.NativeSecurityManager.checkPermission<method*end>(methodCode, methodArgs, frame);
}
default:
return null;
}
} | conventional | public static Result<method*start>io.nuls.contract.vm.Result<method*end> override(MethodCode<method*start>io.nuls.contract.vm.code.MethodCode<method*end> methodCode, MethodArgs<method*start>io.nuls.contract.vm.MethodArgs<method*end> methodArgs, Frame<method*start>io.nuls.contract.vm.Frame<method*end> frame, boolean check) {
switch(methodCode.fullName<method*start>io.nuls.contract.vm.code.MethodCode.fullName<method*end>) {
case getRootGroup<method*start>io.nuls.contract.vm.natives.java.lang.NativeSecurityManager.getRootGroup<method*end>:
if (check) {
return SUPPORT_NATIVE<method*start>io.nuls.contract.vm.natives.NativeMethod.SUPPORT_NATIVE<method*end>;
} else {
return getRootGroup<method*start>io.nuls.contract.vm.natives.java.lang.NativeSecurityManager.getRootGroup<method*end>(methodCode, methodArgs, frame);
}
case checkAccessThread<method*start>io.nuls.contract.vm.natives.java.lang.NativeSecurityManager.checkAccessThread<method*end>:
if (check) {
return SUPPORT_NATIVE<method*start>io.nuls.contract.vm.natives.NativeMethod.SUPPORT_NATIVE<method*end>;
} else {
return checkAccessThread<method*start>io.nuls.contract.vm.natives.java.lang.NativeSecurityManager.checkAccessThread<method*end>(methodCode, methodArgs, frame);
}
case checkAccess<method*start>io.nuls.contract.vm.natives.java.lang.NativeSecurityManager.checkAccess<method*end>:
if (check) {
return SUPPORT_NATIVE<method*start>io.nuls.contract.vm.natives.NativeMethod.SUPPORT_NATIVE<method*end>;
} else {
return checkAccess<method*start>io.nuls.contract.vm.natives.java.lang.NativeSecurityManager.checkAccess<method*end>(methodCode, methodArgs, frame);
}
case checkPropertyAccess<method*start>io.nuls.contract.vm.natives.java.lang.NativeSecurityManager.checkPropertyAccess<method*end>:
if (check) {
return SUPPORT_NATIVE<method*start>io.nuls.contract.vm.natives.NativeMethod.SUPPORT_NATIVE<method*end>;
} else {
return checkPropertyAccess<method*start>io.nuls.contract.vm.natives.java.lang.NativeSecurityManager.checkPropertyAccess<method*end>(methodCode, methodArgs, frame);
}
case checkPermission<method*start>io.nuls.contract.vm.natives.java.lang.NativeSecurityManager.checkPermission<method*end>:
if (check) {
return SUPPORT_NATIVE<method*start>io.nuls.contract.vm.natives.NativeMethod.SUPPORT_NATIVE<method*end>;
} else {
return checkPermission<method*start>io.nuls.contract.vm.natives.java.lang.NativeSecurityManager.checkPermission<method*end>(methodCode, methodArgs, frame);
}
default:
return null;
}
}
|
private Acl<method*start>org.apache.chemistry.opencmis.commons.data.Acl<method*end> compileAcl(Node<method*start>com.openkm.bean.Node<method*end> node) {
AccessControlListImpl<method*start>org.apache.chemistry.opencmis.commons.impl.dataobjects.AccessControlListImpl<method*end> result = new AccessControlListImpl<method*start>org.apache.chemistry.opencmis.commons.impl.dataobjects.AccessControlListImpl<method*end>();
result.setAces<method*start>org.apache.chemistry.opencmis.commons.impl.dataobjects.AccessControlListImpl.setAces<method*end>(new ArrayList<method*start>java.util.ArrayList<method*end><Ace<method*start>org.apache.chemistry.opencmis.commons.data.Ace<method*end>>>());
try {
for (Map.Entry<method*start>java.util.Map.Entry<method*end><String<method*start>java.lang.String<method*end>, Integer> ue : OKMAuth.getInstance<method*start>com.openkm.api.OKMAuth.getInstance<method*end>().getGrantedUsers<method*start>com.openkm.api.OKMAuth.getGrantedUsers<method*end>(null, node.getUuid<method*start>com.openkm.bean.Node.getUuid<method*end>>()).entrySet<method*start>java.util.Map.entrySet<method*end>()) {
// create principal
AccessControlPrincipalDataImpl<method*start>org.apache.chemistry.opencmis.commons.impl.dataobjects.AccessControlPrincipalDataImpl<method*end> principal = new AccessControlPrincipalDataImpl<method*start>org.apache.chemistry.opencmis.commons.impl.dataobjects.AccessControlPrincipalDataImpl<method*end>();
principal.setPrincipalId<method*start>org.apache.chemistry.opencmis.commons.impl.dataobjects.AccessControlPrincipalDataImpl.setPrincipalId<method*end>(ue.getKey<method*start>java.util.Map.Entry.getKey<method*end>>());
// create ACE
AccessControlEntryImpl<method*start>org.apache.chemistry.opencmis.commons.impl.dataobjects.AccessControlEntryImpl<method*end> entry = new AccessControlEntryImpl<method*start>org.apache.chemistry.opencmis.commons.impl.dataobjects.AccessControlEntryImpl<method*end>();
entry.setPrincipal<method*start>org.apache.chemistry.opencmis.commons.impl.dataobjects.AccessControlEntryImpl.setPrincipal<method*end>(principal);
entry.setPermissions<method*start>org.apache.chemistry.opencmis.commons.impl.dataobjects.AccessControlEntryImpl.setPermissions<method*end>(new ArrayList<method*start>java.util.ArrayList<method*end><String<method*start>java.lang.String<method*end>>>());
entry.getPermissions<method*start>org.apache.chemistry.opencmis.commons.impl.dataobjects.AccessControlEntryImpl.getPermissions<method*end>().add<method*start>java.util.List.add<method*end>(CMIS_READ);
entry.getPermissions<method*start>org.apache.chemistry.opencmis.commons.impl.dataobjects.AccessControlEntryImpl.getPermissions<method*end>().add<method*start>java.util.List.add<method*end>(CMIS_WRITE);
}
entry.getPermissions<method*start>org.apache.chemistry.opencmis.commons.impl.dataobjects.AccessControlEntryImpl.getPermissions<method*end>().add<method*start>java.util.List.add<method*end>(CMIS_DELETE);
}
entry.setDirect<method*start>org.apache.chemistry.opencmis.commons.impl.dataobjects.AccessControlEntryImpl.setDirect<method*end>(true);
// add ACE
result.getAces<method*start>org.apache.chemistry.opencmis.commons.impl.dataobjects.AccessControlListImpl.getAces<method*end>().add<method*start>java.util.List.add<method*end>(entry);
}
return result;
} catch (Exception<method*start>java.lang.Exception<method*end> e) {
throw new CmisStorageException<method*start>org.apache.chemistry.opencmis.commons.exceptions.CmisStorageException<method*end>(e.getMessage<method*start>java.lang.Exception.getMessage<method*end>>(), e);
}
} | conventional | private Acl<method*start>org.apache.chemistry.opencmis.commons.data.Acl<method*end> compileAcl(Node<method*start>com.openkm.bean.Node<method*end> node) {
AccessControlListImpl<method*start>org.apache.chemistry.opencmis.commons.impl.dataobjects.AccessControlListImpl<method*end> result = new AccessControlListImpl<method*start>org.apache.chemistry.opencmis.commons.impl.dataobjects.AccessControlListImpl<method*end>();
result.setAces<method*start>org.apache.chemistry.opencmis.commons.impl.dataobjects.AccessControlListImpl.setAces<method*end>(new ArrayList<method*start>java.util.ArrayList<method*end><Ace<method*start>org.apache.chemistry.opencmis.commons.data.Ace<method*end>>());
try {
for (Map.Entry<method*start>java.util.Map.Entry<method*end><String<method*start>java.lang.String<method*end>, Integer> ue : OKMAuth.getInstance<method*start>com.openkm.api.OKMAuth.getInstance<method*end>().getGrantedUsers<method*start>com.openkm.api.OKMAuth.getGrantedUsers<method*end>(null, node.getUuid<method*start>com.openkm.bean.Node.getUuid<method*end>()).entrySet<method*start>java.util.Map.entrySet<method*end>()) {
// create principal
AccessControlPrincipalDataImpl<method*start>org.apache.chemistry.opencmis.commons.impl.dataobjects.AccessControlPrincipalDataImpl<method*end> principal = new AccessControlPrincipalDataImpl<method*start>org.apache.chemistry.opencmis.commons.impl.dataobjects.AccessControlPrincipalDataImpl<method*end>();
principal.setPrincipalId<method*start>org.apache.chemistry.opencmis.commons.impl.dataobjects.AccessControlPrincipalDataImpl.setPrincipalId<method*end>(ue.getKey<method*start>java.util.Map.Entry.getKey<method*end>());
// create ACE
AccessControlEntryImpl<method*start>org.apache.chemistry.opencmis.commons.impl.dataobjects.AccessControlEntryImpl<method*end> entry = new AccessControlEntryImpl<method*start>org.apache.chemistry.opencmis.commons.impl.dataobjects.AccessControlEntryImpl<method*end>();
entry.setPrincipal<method*start>org.apache.chemistry.opencmis.commons.impl.dataobjects.AccessControlEntryImpl.setPrincipal<method*end>(principal);
entry.setPermissions<method*start>org.apache.chemistry.opencmis.commons.impl.dataobjects.AccessControlEntryImpl.setPermissions<method*end>(new ArrayList<method*start>java.util.ArrayList<method*end><String<method*start>java.lang.String<method*end>>());
entry.getPermissions<method*start>org.apache.chemistry.opencmis.commons.impl.dataobjects.AccessControlEntryImpl.getPermissions<method*end>().add<method*start>java.util.List.add<method*end>(CMIS_READ);
if (checkPermission(ue.getValue<method*start>java.util.Map.Entry.getValue<method*end>(), Permission.WRITE<method*start>com.openkm.bean.Permission.WRITE<method*end>)) {
entry.getPermissions<method*start>org.apache.chemistry.opencmis.commons.impl.dataobjects.AccessControlEntryImpl.getPermissions<method*end>().add<method*start>java.util.List.add<method*end>(CMIS_WRITE);
}
if (checkPermission(ue.getValue<method*start>java.util.Map.Entry.getValue<method*end>(), Permission.DELETE<method*start>com.openkm.bean.Permission.DELETE<method*end>)) {
entry.getPermissions<method*start>org.apache.chemistry.opencmis.commons.impl.dataobjects.AccessControlEntryImpl.getPermissions<method*end>().add<method*start>java.util.List.add<method*end>(CMIS_DELETE);
}
entry.setDirect<method*start>org.apache.chemistry.opencmis.commons.impl.dataobjects.AccessControlEntryImpl.setDirect<method*end>(true);
// add ACE
result.getAces<method*start>org.apache.chemistry.opencmis.commons.impl.dataobjects.AccessControlListImpl.getAces<method*end>().add<method*start>java.util.List.add<method*end>(entry);
}
return result;
} catch (Exception<method*start>java.lang.Exception<method*end> e) {
throw new CmisStorageException<method*start>org.apache.chemistry.opencmis.commons.exceptions.CmisStorageException<method*end>(e.getMessage<method*start>java.lang.Exception.getMessage<method*end>(), e);
}
}
|
@Override<method*start>java.lang.Override<method*end>
protected void onCreate(Bundle<method*start>android.os.Bundle<method*end> savedInstanceState) {
super.onCreate<method*start>android.support.v7.app.AppCompatActivity.onCreate<method*end>(savedInstanceState);
setContentView<method*start>android.support.v7.app.AppCompatActivity.setContentView<method*end>(R.layout.activity_main<method*start>org.scalacheck.Gen.R.layout.activity_main<method*end>);
imageView = findViewById<method*start>android.support.v7.app.AppCompatActivity.findViewById<method*end>(R.id.imageView<method*start>org.scalacheck.Gen.R.id.imageView<method*end>);
fab = findViewById<method*start>android.support.v7.app.AppCompatActivity.findViewById<method*end>(R.id.fab<method*start>org.scalacheck.Gen.R.id.fab<method*end>);
fab.setOnClickListener<method*start>android.support.design.widget.FloatingActionButton.setOnClickListener<method*end>(new View.OnClickListener<method*start>android.view.View.OnClickListener<method*end>() {
@Override<method*start>java.lang.Override<method*end>
public void onClick(View<method*start>android.view.View<method*end> view) {
startImageDownload<method*start>com.journaldev.androidretrofitprogressnotification.MainActivity.startImageDownload<method*end>();
} else {
requestPermission<method*start>com.journaldev.androidretrofitprogressnotification.MainActivity.requestPermission<method*end>();
}
}
});
registerReceiver<method*start>com.journaldev.androidretrofitprogressnotification.MainActivity.registerReceiver<method*end>();
} | annotation | @Override<method*start>java.lang.Override<method*end>
protected void onCreate(Bundle<method*start>android.os.Bundle<method*end> savedInstanceState) {
super.onCreate<method*start>android.support.v7.app.AppCompatActivity.onCreate<method*end>(savedInstanceState);
setContentView<method*start>android.support.v7.app.AppCompatActivity.setContentView<method*end>(R.layout.activity_main<method*start>org.scalacheck.Gen.R.layout.activity_main<method*end>);
imageView = findViewById<method*start>android.support.v7.app.AppCompatActivity.findViewById<method*end>(R.id.imageView<method*start>org.scalacheck.Gen.R.id.imageView<method*end>);
fab = findViewById<method*start>android.support.v7.app.AppCompatActivity.findViewById<method*end>(R.id.fab<method*start>org.scalacheck.Gen.R.id.fab<method*end>);
fab.setOnClickListener<method*start>android.support.design.widget.FloatingActionButton.setOnClickListener<method*end>(new View.OnClickListener<method*start>android.view.View.OnClickListener<method*end>() {
@Override<method*start>java.lang.Override<method*end>
public void onClick(View<method*start>android.view.View<method*end> view) {
if (checkPermission<method*start>com.journaldev.androidretrofitprogressnotification.MainActivity.checkPermission<method*end>()) {
startImageDownload<method*start>com.journaldev.androidretrofitprogressnotification.MainActivity.startImageDownload<method*end>();
} else {
requestPermission<method*start>com.journaldev.androidretrofitprogressnotification.MainActivity.requestPermission<method*end>();
}
}
});
registerReceiver<method*start>com.journaldev.androidretrofitprogressnotification.MainActivity.registerReceiver<method*end>();
}
|
public void checkPermission(RoutingContext<method*start>io.vertx.ext.web.RoutingContext<method*end> routingContext) {
QuarkusHttpUser<method*start>io.quarkus.vertx.http.runtime.security.QuarkusHttpUser<method*end> user = (QuarkusHttpUser<method*start>io.quarkus.vertx.http.runtime.security.QuarkusHttpUser<method*end>) routingContext.user<method*start>io.vertx.ext.web.RoutingContext.user<method*end>();
// check the anonymous identity
attemptAnonymousAuthentication<method*start>io.quarkus.vertx.http.runtime.security.HttpAuthorizer.attemptAnonymousAuthentication<method*end>(routingContext);
} else {
// we have a user, check their permissions
doPermissionCheck<method*start>io.quarkus.vertx.http.runtime.security.HttpAuthorizer.doPermissionCheck<method*end>(routingContext, user.getSecurityIdentity<method*start>io.quarkus.vertx.http.runtime.security.QuarkusHttpUser.getSecurityIdentity<method*end>(), 0, policies);
}
}
| conventional | public void checkPermission(RoutingContext<method*start>io.vertx.ext.web.RoutingContext<method*end> routingContext) {
QuarkusHttpUser<method*start>io.quarkus.vertx.http.runtime.security.QuarkusHttpUser<method*end> user = (QuarkusHttpUser<method*start>io.quarkus.vertx.http.runtime.security.QuarkusHttpUser<method*end>) routingContext.user<method*start>io.vertx.ext.web.RoutingContext.user<method*end>();
if (user == null) {
// check the anonymous identity
attemptAnonymousAuthentication<method*start>io.quarkus.vertx.http.runtime.security.HttpAuthorizer.attemptAnonymousAuthentication<method*end>(routingContext);
} else {
// we have a user, check their permissions
doPermissionCheck<method*start>io.quarkus.vertx.http.runtime.security.HttpAuthorizer.doPermissionCheck<method*end>(routingContext, user.getSecurityIdentity<method*start>io.quarkus.vertx.http.runtime.security.QuarkusHttpUser.getSecurityIdentity<method*end>(), 0, policies);
}
}
|
@Override<method*start>java.lang.Override<method*end>
public void checkAccess(Thread<method*start>java.lang.Thread<method*end> t) {
throw new NullPointerException<method*start>java.lang.NullPointerException<method*end>("ODPS-0730001: thread can't be null");
}
try {
} catch (SecurityException<method*start>java.lang.SecurityException<method*end> e) {
throw new SecurityException<method*start>java.lang.SecurityException<method*end>("ODPS-0730001: " + e.getMessage<method*start>java.lang.SecurityException.getMessage<method*end>());
}
} | annotation | @Override<method*start>java.lang.Override<method*end>
public void checkAccess(Thread<method*start>java.lang.Thread<method*end> t) {
super.checkAccess<method*start>java.lang.SecurityManager.checkAccess<method*end>(t);
if (t == null) {
throw new NullPointerException<method*start>java.lang.NullPointerException<method*end>("ODPS-0730001: thread can't be null");
}
try {
checkPermission<method*start>java.lang.SecurityManager.checkPermission<method*end>(SecurityConstants.MODIFY_THREADGROUP_PERMISSION<method*start>sun.security.util.SecurityConstants.MODIFY_THREADGROUP_PERMISSION<method*end>);
} catch (SecurityException<method*start>java.lang.SecurityException<method*end> e) {
throw new SecurityException<method*start>java.lang.SecurityException<method*end>("ODPS-0730001: " + e.getMessage<method*start>java.lang.SecurityException.getMessage<method*end>());
}
}
|
@Override
public FileSystem newFileSystem(URI uri, Map env) throws IOException {
Objects.requireNonNull(env);
if (env.containsKey("java.home")) {
return newFileSystem((String) env.get("java.home"), uri, env);
} else {
return new JrtFileSystem(this, env);
}
} | conventional | @Override<method*start>java.lang.Override<method*end>
public FileSystem<method*start>java.io.FileSystem<method*end> newFileSystem(URI<method*start>java.net.URI<method*end> uri, Map<method*start>java.util.Map<method*end><String<method*start>java.lang.String<method*end>, ?> env) throws IOException<method*start>java.io.IOException<method*end> {
Objects.requireNonNull<method*start>java.util.Objects.requireNonNull<method*end>(env);
checkPermission();
checkUri(uri);
if (env.containsKey<method*start>java.util.Map.containsKey<method*end>("java.home")) {
return newFileSystem((String<method*start>java.lang.String<method*end>) env.get<method*start>java.util.Map.get<method*end>("java.home"), uri, env);
} else {
return new JrtFileSystem(this, env);
}
}
|
@Override
public URL getEntry(String name) {
try {
} catch (Exception e) {
// No permission
return null;
}
}
return getFramework().getBundleEntry(this, name);
} | annotation | @Override<method*start>java.lang.Override<method*end>
public URL<method*start>java.net.URL<method*end> getEntry(String<method*start>java.lang.String<method*end> name) {
Object<method*start>java.lang.Object<method*end> sm = System.getSecurityManager<method*start>java.lang.System.getSecurityManager<method*end>();
if (sm != null) {
try {
((SecurityManager<method*start>java.lang.SecurityManager<method*end>) sm).checkPermission<method*start>java.lang.SecurityManager.checkPermission<method*end>(new AdminPermission<method*start>org.osgi.framework.AdminPermission<method*end>(this, AdminPermission.RESOURCE<method*start>org.osgi.framework.AdminPermission.RESOURCE<method*end>));
} catch (Exception<method*start>java.lang.Exception<method*end> e) {
// No permission
return null;
}
}
return getFramework().getBundleEntry<method*start>org.apache.felix.framework.Felix.getBundleEntry<method*end>(this, name);
}
|
@Path<method*start>javax.ws.rs.Path<method*end>("{id}/accumulators")
@PUT<method*start>javax.ws.rs.PUT<method*end>
public Response<method*start>javax.ws.rs.core.Response<method*end> updateAccumulators(DeviceAccumulators<method*start>org.traccar.model.DeviceAccumulators<method*end> entity) throws SQLException<method*start>java.sql.SQLException<method*end> {
Context.getDeviceManager<method*start>org.traccar.Context.getDeviceManager<method*end>().resetDeviceAccumulators<method*start>org.traccar.database.DeviceManager.resetDeviceAccumulators<method*end>(entity);
LogAction.resetDeviceAccumulators<method*start>org.traccar.helper.LogAction.resetDeviceAccumulators<method*end>(getUserId<method*start>org.traccar.api.BaseResource.getUserId<method*end>(), entity.getDeviceId<method*start>org.traccar.model.DeviceAccumulators.getDeviceId<method*end>());
return Response.noContent<method*start>javax.ws.rs.core.Response.noContent<method*end>().build<method*start>javax.ws.rs.core.Response.ResponseBuilder.build<method*end>();
} | annotation | @Path<method*start>javax.ws.rs.Path<method*end>("{id}/accumulators")
@PUT<method*start>javax.ws.rs.PUT<method*end>
public Response<method*start>javax.ws.rs.core.Response<method*end> updateAccumulators(DeviceAccumulators<method*start>org.traccar.model.DeviceAccumulators<method*end> entity) throws SQLException<method*start>java.sql.SQLException<method*end> {
if (!Context.getPermissionsManager<method*start>org.traccar.Context.getPermissionsManager<method*end>().getUserAdmin<method*start>org.traccar.database.PermissionsManager.getUserAdmin<method*end>(getUserId<method*start>org.traccar.api.BaseResource.getUserId<method*end>())) {
Context.getPermissionsManager<method*start>org.traccar.Context.getPermissionsManager<method*end>().checkManager<method*start>org.traccar.database.PermissionsManager.checkManager<method*end>(getUserId<method*start>org.traccar.api.BaseResource.getUserId<method*end>());
Context.getPermissionsManager<method*start>org.traccar.Context.getPermissionsManager<method*end>().checkPermission<method*start>org.traccar.database.PermissionsManager.checkPermission<method*end>(Device<method*start>org.traccar.model.Device<method*end>.class, getUserId<method*start>org.traccar.api.BaseResource.getUserId<method*end>(), entity.getDeviceId<method*start>org.traccar.model.DeviceAccumulators.getDeviceId<method*end>());
}
Context.getDeviceManager<method*start>org.traccar.Context.getDeviceManager<method*end>().resetDeviceAccumulators<method*start>org.traccar.database.DeviceManager.resetDeviceAccumulators<method*end>(entity);
LogAction.resetDeviceAccumulators<method*start>org.traccar.helper.LogAction.resetDeviceAccumulators<method*end>(getUserId<method*start>org.traccar.api.BaseResource.getUserId<method*end>(), entity.getDeviceId<method*start>org.traccar.model.DeviceAccumulators.getDeviceId<method*end>());
return Response.noContent<method*start>javax.ws.rs.core.Response.noContent<method*end>().build<method*start>javax.ws.rs.core.Response.ResponseBuilder.build<method*end>();
}
|
@Override<method*start>java.lang.Override<method*end>
public void checkAccess(ThreadGroup<method*start>java.lang.ThreadGroup<method*end> g) {
throw new NullPointerException<method*start>java.lang.NullPointerException<method*end>("ODPS-0730001: thread group can't be null");
}
try {
} catch (SecurityException<method*start>java.lang.SecurityException<method*end> e) {
throw new SecurityException<method*start>java.lang.SecurityException<method*end>("ODPS-0730001: " + e.getMessage<method*start>java.lang.SecurityException.getMessage<method*end>());
}
} | annotation | @Override<method*start>java.lang.Override<method*end>
public void checkAccess(ThreadGroup<method*start>java.lang.ThreadGroup<method*end> g) {
super.checkAccess<method*start>java.lang.SecurityManager.checkAccess<method*end>(g);
if (g == null) {
throw new NullPointerException<method*start>java.lang.NullPointerException<method*end>("ODPS-0730001: thread group can't be null");
}
try {
checkPermission<method*start>java.lang.SecurityManager.checkPermission<method*end>(SecurityConstants.MODIFY_THREADGROUP_PERMISSION<method*start>sun.security.util.SecurityConstants.MODIFY_THREADGROUP_PERMISSION<method*end>);
} catch (SecurityException<method*start>java.lang.SecurityException<method*end> e) {
throw new SecurityException<method*start>java.lang.SecurityException<method*end>("ODPS-0730001: " + e.getMessage<method*start>java.lang.SecurityException.getMessage<method*end>());
}
}
|
private FileSystem<method*start>java.io.FileSystem<method*end> getTheFileSystem() {
FileSystem<method*start>java.io.FileSystem<method*end> fs = this.theFileSystem<method*start>jdk.internal.jrtfs.JrtFileSystemProvider.theFileSystem<method*end>;
if (fs == null) {
synchronized (this) {
fs = this.theFileSystem<method*start>jdk.internal.jrtfs.JrtFileSystemProvider.theFileSystem<method*end>;
if (fs == null) {
try {
this.theFileSystem<method*start>jdk.internal.jrtfs.JrtFileSystemProvider.theFileSystem<method*end> = fs = new JrtFileSystem(this, null);
} catch (IOException<method*start>java.io.IOException<method*end> ioe) {
throw new InternalError<method*start>java.lang.InternalError<method*end>(ioe);
}
}
}
}
return fs;
}
| conventional | private FileSystem<method*start>java.io.FileSystem<method*end> getTheFileSystem() {
checkPermission<method*start>jdk.internal.jrtfs.JrtFileSystemProvider.checkPermission<method*end>();
FileSystem<method*start>java.io.FileSystem<method*end> fs = this.theFileSystem<method*start>jdk.internal.jrtfs.JrtFileSystemProvider.theFileSystem<method*end>;
if (fs == null) {
synchronized (this) {
fs = this.theFileSystem<method*start>jdk.internal.jrtfs.JrtFileSystemProvider.theFileSystem<method*end>;
if (fs == null) {
try {
this.theFileSystem<method*start>jdk.internal.jrtfs.JrtFileSystemProvider.theFileSystem<method*end> = fs = new JrtFileSystem(this, null);
} catch (IOException<method*start>java.io.IOException<method*end> ioe) {
throw new InternalError<method*start>java.lang.InternalError<method*end>(ioe);
}
}
}
}
return fs;
}
|
public CertificateList<method*start>org.bouncycastle.asn1.x509.CertificateList<method*end> getCrl(CmpRequestorInfo<method*start>org.xipki.ca.api.mgmt.RequestorInfo.CmpRequestorInfo<method*end> requestor, BigInteger<method*start>java.math.BigInteger<method*end> crlNumber) throws OperationException<method*start>org.xipki.ca.api.OperationException<method*end> {
Args.notNull<method*start>org.xipki.util.Args.notNull<method*end>(requestor, "requestor");
X509Ca ca = getCa();
return (crlNumber == null) ? ca.getBcCurrentCrl<method*start>org.xipki.ca.server.X509Ca.getBcCurrentCrl<method*end>() : ca.getBcCrl<method*start>org.xipki.ca.server.X509Ca.getBcCrl<method*end>(crlNumber);
} | conventional | public CertificateList<method*start>org.bouncycastle.asn1.x509.CertificateList<method*end> getCrl(CmpRequestorInfo<method*start>org.xipki.ca.api.mgmt.RequestorInfo.CmpRequestorInfo<method*end> requestor, BigInteger<method*start>java.math.BigInteger<method*end> crlNumber) throws OperationException<method*start>org.xipki.ca.api.OperationException<method*end> {
Args.notNull<method*start>org.xipki.util.Args.notNull<method*end>(requestor, "requestor");
try {
checkPermission(requestor, PermissionConstants.GET_CRL<method*start>org.xipki.ca.api.mgmt.PermissionConstants.GET_CRL<method*end>);
} catch (InsuffientPermissionException ex) {
throw new OperationException<method*start>org.xipki.ca.api.OperationException<method*end>(ErrorCode.NOT_PERMITTED<method*start>org.xipki.ca.api.OperationException.ErrorCode.NOT_PERMITTED<method*end>, ex.getMessage<method*start>java.lang.Exception.getMessage<method*end>());
}
X509Ca ca = getCa();
return (crlNumber == null) ? ca.getBcCurrentCrl<method*start>org.xipki.ca.server.X509Ca.getBcCurrentCrl<method*end>() : ca.getBcCrl<method*start>org.xipki.ca.server.X509Ca.getBcCrl<method*end>(crlNumber);
}
|
public void updateConfiguration(Function<String, BiFunction<String, String, String>> mapper) throws IOException {
ensureLogManagerInitialized();
drainLoggerRefQueueBounded();
String fname = getConfigurationFileName();
try (final InputStream in = new FileInputStream(fname)) {
final BufferedInputStream bin = new BufferedInputStream(in);
updateConfiguration(bin, mapper);
}
} | conventional | public void upd<method*start>java.io.IOException<method*end>ateConfiguration(Function<<method*start>java.util.logging.LogManager.checkPermission<method*end>String, BiFunction<String, String, String>> mapper) throws IOException {
checkPermissio<method*start>java.lang.String<method*end>n();
ensureLogManagerInitialized();
drainLoggerRefQ<method*start>java.io.InputStream<method*end>ueueBounded();
String fname = getConfigurationFileName();
try (final InputStream in = n<method*start>java.io.BufferedInputStream<method*end>ew FileInputStream(fname)) {
final BufferedInputStream bin = new BufferedInputStream(in);
updateConfiguration(bin, mapper);
}
}
|
@Deprecated<method*start>java.lang.Deprecated<method*end>
public static void setLogStream(java.io.PrintStream<method*start>java.io.PrintStream<method*end> out) {
SecurityManager<method*start>java.lang.SecurityManager<method*end> sec = System.getSecurityManager<method*start>java.lang.System.getSecurityManager<method*end>();
logStream = out;
if (out != null)
logWriter = new java.io.PrintWriter<method*start>java.io.PrintWriter<method*end>(out);
else
logWriter = null;
} | annotation | @Deprecated<method*start>java.lang.Deprecated<method*end>
public static void setLogStream(java.io.PrintStream<method*start>java.io.PrintStream<method*end> out) {
SecurityManager<method*start>java.lang.SecurityManager<method*end> sec = System.getSecurityManager<method*start>java.lang.System.getSecurityManager<method*end>();
if (sec != null) {
sec.checkPermission<method*start>java.lang.SecurityManager.checkPermission<method*end>(SET_LOG_PERMISSION);
}
logStream = out;
if (out != null)
logWriter = new java.io.PrintWriter<method*start>java.io.PrintWriter<method*end>(out);
else
logWriter = null;
}
|
@Deprecated
public void addPropertyChangeListener(PropertyChangeListener l) throws SecurityException {
PropertyChangeListener listener = Objects.requireNonNull(l);
synchronized (listenerMap) {
// increment the registration count if already registered
Integer value = listenerMap.get(listener);
value = (value == null) ? 1 : (value + 1);
listenerMap.put(listener, value);
}
} | annotation | @Deprecated<method*start>java.lang.Deprecated<method*end>
public void addPropertyChangeListener(PropertyChangeListener<method*start>java.beans.PropertyChangeListener<method*end> l) throws SecurityException<method*start>java.lang.SecurityException<method*end> {
PropertyChangeListener<method*start>java.beans.PropertyChangeListener<method*end> listener = Objects.requireNonNull<method*start>java.util.Objects.requireNonNull<method*end>(l);
checkPermission<method*start>java.util.logging.LogManager.checkPermission<method*end>();
synchronized (listenerMap) {
// increment the registration count if already registered
Integer value = listenerMap.get<method*start>java.util.Map.get<method*end>(listener);
value = (value == null) ? 1 : (value + 1);
listenerMap.put<method*start>java.util.Map.put<method*end>(listener, value);
}
}
|
public Menu<method*start>org.apache.roller.weblogger.ui.core.util.menu.Menu<method*end> getAdminMenu() {
try {
GlobalPermission<method*start>org.apache.roller.weblogger.pojos.GlobalPermission<method*end> adminPerm = new GlobalPermission(Collections.singletonList<method*start>java.util.Collections.singletonList<method*end>(GlobalPermission.ADMIN<method*start>org.apache.roller.weblogger.pojos.GlobalPermission.ADMIN<method*end>));
boolean hasAdmin = WebloggerFactory.getWeblogger<method*start>org.apache.roller.weblogger.business.WebloggerFactory.getWeblogger<method*end>().getUserManager<method*start>org.apache.roller.weblogger.business.Weblogger.getUserManager<method*end>().checkPermission<method*start>org.apache.roller.weblogger.business.UserManager.checkPermission<method*end>(adminPerm, pageRequest.getUser<method*start>org.apache.roller.weblogger.ui.rendering.util.ParsedRequest.getUser<method*end>());
return MenuHelper.getMenu<method*start>org.apache.roller.weblogger.ui.core.util.menu.MenuHelper.getMenu<method*end>("admin", "noAction", pageRequest.getUser<method*start>org.apache.roller.weblogger.ui.rendering.util.ParsedRequest.getUser<method*end>(), pageRequest.getWeblog<method*start>org.apache.roller.weblogger.ui.rendering.util.WeblogRequest.getWeblog<method*end>());
} catch (WebloggerException ex) {
logger.debug<method*start>org.apache.commons.logging.Log.debug<method*end>("ERROR: fetching user roles");
}
return null;
}
| annotation | public Menu<method*start>org.apache.roller.weblogger.ui.core.util.menu.Menu<method*end> getAdminMenu() {
try {
GlobalPermission<method*start>org.apache.roller.weblogger.pojos.GlobalPermission<method*end> adminPerm = new GlobalPermission(Collections.singletonList<method*start>java.util.Collections.singletonList<method*end>(GlobalPermission.ADMIN<method*start>org.apache.roller.weblogger.pojos.GlobalPermission.ADMIN<method*end>));
boolean hasAdmin = WebloggerFactory.getWeblogger<method*start>org.apache.roller.weblogger.business.WebloggerFactory.getWeblogger<method*end>().getUserManager<method*start>org.apache.roller.weblogger.business.Weblogger.getUserManager<method*end>().checkPermission<method*start>org.apache.roller.weblogger.business.UserManager.checkPermission<method*end>(adminPerm, pageRequest.getUser<method*start>org.apache.roller.weblogger.ui.rendering.util.ParsedRequest.getUser<method*end>());
if (pageRequest.isLoggedIn<method*start>org.apache.roller.weblogger.ui.rendering.util.ParsedRequest.isLoggedIn<method*end>() && hasAdmin) {
return MenuHelper.getMenu<method*start>org.apache.roller.weblogger.ui.core.util.menu.MenuHelper.getMenu<method*end>("admin", "noAction", pageRequest.getUser<method*start>org.apache.roller.weblogger.ui.rendering.util.ParsedRequest.getUser<method*end>(), pageRequest.getWeblog<method*start>org.apache.roller.weblogger.ui.rendering.util.WeblogRequest.getWeblog<method*end>());
}
} catch (WebloggerException ex) {
logger.debug<method*start>org.apache.commons.logging.Log.debug<method*end>("ERROR: fetching user roles");
}
return null;
}
|
@Override
public ClassLoader getClassLoader() {
ClassLoader result = context.getLoader().getClassLoader();
if (Globals.IS_SECURITY_ENABLED) {
ClassLoader tccl = Thread.currentThread().getContextClassLoader();
ClassLoader parent = result;
while (parent != null) {
parent = parent.getParent();
}
if (parent == null) {
System.getSecurityManager().checkPermission(new RuntimePermission("getClassLoader"));
}
}
return result;
} | annotation | @Override<method*start>java.lang.Override<method*end>
public ClassLoader<method*start>java.lang.ClassLoader<method*end> getClassLoader() {
ClassLoader<method*start>java.lang.ClassLoader<method*end> result = context.getLoader<method*start>org.apache.catalina.core.StandardContext.getLoader<method*end>().getClassLoader<method*start>org.apache.catalina.Loader.getClassLoader<method*end>();
if (Globals.IS_SECURITY_ENABLED<method*start>org.apache.catalina.Globals.IS_SECURITY_ENABLED<method*end>) {
ClassLoader<method*start>java.lang.ClassLoader<method*end> tccl = Thread.currentThread<method*start>java.lang.Thread.currentThread<method*end>().getContextClassLoader<method*start>java.lang.Thread.getContextClassLoader<method*end>();
ClassLoader<method*start>java.lang.ClassLoader<method*end> parent = result;
while (parent != null) {
if (parent == tccl) {
break;
}
parent = parent.getParent<method*start>java.lang.ClassLoader.getParent<method*end>();
}
if (parent == null) {
System.getSecurityManager<method*start>java.lang.System.getSecurityManager<method*end>().checkPermission<method*start>java.lang.SecurityManager.checkPermission<method*end>(new RuntimePermission<method*start>java.lang.RuntimePermission<method*end>("getClassLoader"));
}
}
return result;
}
|
@Path<method*start>javax.ws.rs.Path<method*end>("{id}/accumulators")
@PUT<method*start>javax.ws.rs.PUT<method*end>
public Response<method*start>javax.ws.rs.core.Response<method*end> updateAccumulators(DeviceAccumulators<method*start>org.traccar.model.DeviceAccumulators<method*end> entity) throws SQLException<method*start>java.sql.SQLException<method*end> {
Context.getPermissionsManager<method*start>org.traccar.Context.getPermissionsManager<method*end>().checkManager<method*start>org.traccar.database.PermissionsManager.checkManager<method*end>(getUserId<method*start>org.traccar.api.BaseResource.getUserId<method*end>());
Context.getPermissionsManager<method*start>org.traccar.Context.getPermissionsManager<method*end>().checkPermission<method*start>org.traccar.database.PermissionsManager.checkPermission<method*end>(Device<method*start>org.traccar.model.Device<method*end>.class, getUserId<method*start>org.traccar.api.BaseResource.getUserId<method*end>(), entity.getDeviceId<method*start>org.traccar.model.DeviceAccumulators.getDeviceId<method*end>());
}
Context.getDeviceManager<method*start>org.traccar.Context.getDeviceManager<method*end>().resetDeviceAccumulators<method*start>org.traccar.database.DeviceManager.resetDeviceAccumulators<method*end>(entity);
LogAction.resetDeviceAccumulators<method*start>org.traccar.helper.LogAction.resetDeviceAccumulators<method*end>(getUserId<method*start>org.traccar.api.BaseResource.getUserId<method*end>(), entity.getDeviceId<method*start>org.traccar.model.DeviceAccumulators.getDeviceId<method*end>());
return Response.noContent<method*start>javax.ws.rs.core.Response.noContent<method*end>().build<method*start>javax.ws.rs.core.Response.ResponseBuilder.build<method*end>();
}
| annotation | @Path<method*start>javax.ws.rs.Path<method*end>("{id}/accumulators")
@PUT<method*start>javax.ws.rs.PUT<method*end>
public Response<method*start>javax.ws.rs.core.Response<method*end> updateAccumulators(DeviceAccumulators<method*start>org.traccar.model.DeviceAccumulators<method*end> entity) throws SQLException<method*start>java.sql.SQLException<method*end> {
if (!Context.getPermissionsManager<method*start>org.traccar.Context.getPermissionsManager<method*end>().getUserAdmin<method*start>org.traccar.database.PermissionsManager.getUserAdmin<method*end>(getUserId<method*start>org.traccar.api.BaseResource.getUserId<method*end>())) {
Context.getPermissionsManager<method*start>org.traccar.Context.getPermissionsManager<method*end>().checkManager<method*start>org.traccar.database.PermissionsManager.checkManager<method*end>(getUserId<method*start>org.traccar.api.BaseResource.getUserId<method*end>());
Context.getPermissionsManager<method*start>org.traccar.Context.getPermissionsManager<method*end>().checkPermission<method*start>org.traccar.database.PermissionsManager.checkPermission<method*end>(Device<method*start>org.traccar.model.Device<method*end>.class, getUserId<method*start>org.traccar.api.BaseResource.getUserId<method*end>(), entity.getDeviceId<method*start>org.traccar.model.DeviceAccumulators.getDeviceId<method*end>());
}
Context.getDeviceManager<method*start>org.traccar.Context.getDeviceManager<method*end>().resetDeviceAccumulators<method*start>org.traccar.database.DeviceManager.resetDeviceAccumulators<method*end>(entity);
LogAction.resetDeviceAccumulators<method*start>org.traccar.helper.LogAction.resetDeviceAccumulators<method*end>(getUserId<method*start>org.traccar.api.BaseResource.getUserId<method*end>(), entity.getDeviceId<method*start>org.traccar.model.DeviceAccumulators.getDeviceId<method*end>());
return Response.noContent<method*start>javax.ws.rs.core.Response.noContent<method*end>().build<method*start>javax.ws.rs.core.Response.ResponseBuilder.build<method*end>();
}
|
public boolean hasPermissionAnd(String... name) {
for (boolean b : permitted) {
// 必须所有的权限都有，才成功
return false;
}
return true;
} | conventional | public boolean hasPermissionAnd(String<method*start>java.lang.String<method*end>... name) {
boolean[] permitted = SecurityUtils.getSubject<method*start>org.apache.shiro.SecurityUtils.getSubject<method*end>().isPermitted<method*start>org.apache.shiro.subject.Subject.isPermitted<method*end>(name);
for (boolean b : permitted) {
// 必须所有的权限都有，才成功
if (!b) {
return false;
}
}
return true;
}
|
@Override<method*start>java.lang.Override<method*end>
public void checkAccess(ThreadGroup<method*start>java.lang.ThreadGroup<method*end> g) {
throw new NullPointerException<method*start>java.lang.NullPointerException<method*end>("ODPS-0730001: thread group can't be null");
}
try {
checkPermission<method*start>java.lang.SecurityManager.checkPermission<method*end>(SecurityConstants.MODIFY_THREADGROUP_PERMISSION<method*start>sun.security.util.SecurityConstants.MODIFY_THREADGROUP_PERMISSION<method*end>);
} catch (SecurityException<method*start>java.lang.SecurityException<method*end> e) {
throw new SecurityException<method*start>java.lang.SecurityException<method*end>("ODPS-0730001: " + e.getMessage<method*start>java.lang.SecurityException.getMessage<method*end>());
}
}
| annotation | @Override<method*start>java.lang.Override<method*end>
public void checkAccess(ThreadGroup<method*start>java.lang.ThreadGroup<method*end> g) {
super.checkAccess<method*start>java.lang.SecurityManager.checkAccess<method*end>(g);
if (g == null) {
throw new NullPointerException<method*start>java.lang.NullPointerException<method*end>("ODPS-0730001: thread group can't be null");
}
try {
checkPermission<method*start>java.lang.SecurityManager.checkPermission<method*end>(SecurityConstants.MODIFY_THREADGROUP_PERMISSION<method*start>sun.security.util.SecurityConstants.MODIFY_THREADGROUP_PERMISSION<method*end>);
} catch (SecurityException<method*start>java.lang.SecurityException<method*end> e) {
throw new SecurityException<method*start>java.lang.SecurityException<method*end>("ODPS-0730001: " + e.getMessage<method*start>java.lang.SecurityException.getMessage<method*end>());
}
}
|
@Override
public boolean hasPermission(Authentication authentication, Object targetUrl, Object permission) {
// 获取用户信息
SelfUserEntity selfUserEntity = (SelfUserEntity) authentication.getPrincipal();
// 查询用户权限(这里可以将权限放入缓存中提升效率)
Set<String> permissions = new HashSet<>();
List<SysMenuEntity> sysMenuEntityList = sysUserService.selectSysMenuByUserId(selfUserEntity.getUserId());
for (SysMenuEntity sysMenuEntity : sysMenuEntityList) {
permissions.add(sysMenuEntity.getPermission());
}
return false;
} | annotation | @Override<method*start>java.lang.Override<method*end>
public boolean hasPermission(Authentication<method*start>org.springframework.security.core.Authentication<method*end> authentication, Object<method*start>java.lang.Object<method*end> targetUrl, Object<method*start>java.lang.Object<method*end> permission) {
// 获取用户信息
SelfUserEntity<method*start>com.sans.security.entity.SelfUserEntity<method*end> selfUserEntity = (SelfUserEntity<method*start>com.sans.security.entity.SelfUserEntity<method*end>) authentication.getPrincipal<method*start>org.springframework.security.core.Authentication.getPrincipal<method*end>();
// 查询用户权限(这里可以将权限放入缓存中提升效率)
Set<method*start>java.util.Set<method*end><String<method*start>java.lang.String<method*end>> permissions = new HashSet<method*start>java.util.HashSet<method*end><>();
List<method*start>java.util.List<method*end><SysMenuEntity<method*start>com.sans.core.entity.SysMenuEntity<method*end>> sysMenuEntityList = sysUserService.selectSysMenuByUserId<method*start>com.sans.core.service.SysUserService.selectSysMenuByUserId<method*end>(selfUserEntity.getUserId<method*start>com.sans.security.entity.SelfUserEntity.getUserId<method*end>());
for (SysMenuEntity<method*start>com.sans.core.entity.SysMenuEntity<method*end> sysMenuEntity : sysMenuEntityList) {
permissions.add<method*start>java.util.Set.add<method*end>(sysMenuEntity.getPermission<method*start>com.sans.core.entity.SysMenuEntity.getPermission<method*end>());
}
// 权限对比
if (permissions.contains<method*start>java.util.Set.contains<method*end>(permission.toString<method*start>java.lang.Object.toString<method*end>())) {
return true;
}
return false;
}
|
public CertificateList<method*start>org.bouncycastle.asn1.x509.CertificateList<method*end> getCrl(CmpRequestorInfo<method*start>org.xipki.ca.api.mgmt.RequestorInfo.CmpRequestorInfo<method*end> requestor, BigInteger<method*start>java.math.BigInteger<method*end> crlNumber) throws OperationException<method*start>org.xipki.ca.api.OperationException<method*end> {
Args.notNull<method*start>org.xipki.util.Args.notNull<method*end>(requestor, "requestor");
try {
} catch (InsuffientPermissionException ex) {
throw new OperationException<method*start>org.xipki.ca.api.OperationException<method*end>(ErrorCode.NOT_PERMITTED<method*start>org.xipki.ca.api.OperationException.ErrorCode.NOT_PERMITTED<method*end>, ex.getMessage<method*start>java.lang.Exception.getMessage<method*end>());
}
X509Ca ca = getCa();
return (crlNumber == null) ? ca.getBcCurrentCrl<method*start>org.xipki.ca.server.X509Ca.getBcCurrentCrl<method*end>() : ca.getBcCrl<method*start>org.xipki.ca.server.X509Ca.getBcCrl<method*end>(crlNumber);
}
| conventional | public CertificateList<method*start>org.bouncycastle.asn1.x509.CertificateList<method*end> getCrl(CmpRequestorInfo<method*start>org.xipki.ca.api.mgmt.RequestorInfo.CmpRequestorInfo<method*end> requestor, BigInteger<method*start>java.math.BigInteger<method*end> crlNumber) throws OperationException<method*start>org.xipki.ca.api.OperationException<method*end> {
Args.notNull<method*start>org.xipki.util.Args.notNull<method*end>(requestor, "requestor");
try {
checkPermission(requestor, PermissionConstants.GET_CRL<method*start>org.xipki.ca.api.mgmt.PermissionConstants.GET_CRL<method*end>);
} catch (InsuffientPermissionException ex) {
throw new OperationException<method*start>org.xipki.ca.api.OperationException<method*end>(ErrorCode.NOT_PERMITTED<method*start>org.xipki.ca.api.OperationException.ErrorCode.NOT_PERMITTED<method*end>, ex.getMessage<method*start>java.lang.Exception.getMessage<method*end>());
}
X509Ca ca = getCa();
return (crlNumber == null) ? ca.getBcCurrentCrl<method*start>org.xipki.ca.server.X509Ca.getBcCurrentCrl<method*end>() : ca.getBcCrl<method*start>org.xipki.ca.server.X509Ca.getBcCrl<method*end>(crlNumber);
}
|
public void updateConfiguration(Function<String, BiFunction<String, String, String>> mapper) throws IOException {
ensureLogManagerInitialized();
drainLoggerRefQueueBounded();
String fname = getConfigurationFileName();
try (final InputStream in = new FileInputStream(fname)) {
final BufferedInputStream bin = new BufferedInputStream(in);
updateConfiguration(bin, mapper);
}
} | conventional | public void upd<method*start>java.io.IOException<method*end>ateConfiguration(Function<<method*start>java.util.logging.LogManager.checkPermission<method*end>String, BiFunction<String, String, String>> mapper) throws IOException {
checkPermissio<method*start>java.lang.String<method*end>n();
ensureLogManagerInitialized();
drainLoggerRefQ<method*start>java.io.InputStream<method*end>ueueBounded();
String fname = getConfigurationFileName();
try (final InputStream in = n<method*start>java.io.BufferedInputStream<method*end>ew FileInputStream(fname)) {
final BufferedInputStream bin = new BufferedInputStream(in);
updateConfiguration(bin, mapper);
}
}
|
@Deprecated
public static void setLogStream(java.io.PrintStream out) {
logStream = out;
if (out != null)
logWriter = new java.io.PrintWriter(out);
else
logWriter = null;
} | annotation | @Deprecated<method*start>java.lang.Deprecated<method*end>
public static void setLogStream(java.io.PrintStream<method*start>java.io.PrintStream<method*end> out) {
SecurityManager<method*start>java.lang.SecurityManager<method*end> sec = System.getSecurityManager<method*start>java.lang.System.getSecurityManager<method*end>();
if (sec != null) {
sec.checkPermission<method*start>java.lang.SecurityManager.checkPermission<method*end>(SET_LOG_PERMISSION);
}
logStream = out;
if (out != null)
logWriter = new java.io.PrintWriter<method*start>java.io.PrintWriter<method*end>(out);
else
logWriter = null;
}
|
@Deprecated<method*start>java.lang.Deprecated<method*end>
public void addPropertyChangeListener(PropertyChangeListener<method*start>java.beans.PropertyChangeListener<method*end> l) throws SecurityException<method*start>java.lang.SecurityException<method*end> {
PropertyChangeListener<method*start>java.beans.PropertyChangeListener<method*end> listener = Objects.requireNonNull<method*start>java.util.Objects.requireNonNull<method*end>(l);
synchronized (listenerMap) {
// increment the registration count if already registered
Integer value = listenerMap.get<method*start>java.util.Map.get<method*end>(listener);
value = (value == null) ? 1 : (value + 1);
listenerMap.put<method*start>java.util.Map.put<method*end>(listener, value);
}
} | annotation | @Deprecated<method*start>java.lang.Deprecated<method*end>
public void addPropertyChangeListener(PropertyChangeListener<method*start>java.beans.PropertyChangeListener<method*end> l) throws SecurityException<method*start>java.lang.SecurityException<method*end> {
PropertyChangeListener<method*start>java.beans.PropertyChangeListener<method*end> listener = Objects.requireNonNull<method*start>java.util.Objects.requireNonNull<method*end>(l);
checkPermission<method*start>java.util.logging.LogManager.checkPermission<method*end>();
synchronized (listenerMap) {
// increment the registration count if already registered
Integer value = listenerMap.get<method*start>java.util.Map.get<method*end>(listener);
value = (value == null) ? 1 : (value + 1);
listenerMap.put<method*start>java.util.Map.put<method*end>(listener, value);
}
}
|
public Menu<method*start>org.apache.roller.weblogger.ui.core.util.menu.Menu<method*end> getAdminMenu() {
try {
GlobalPermission<method*start>org.apache.roller.weblogger.pojos.GlobalPermission<method*end> adminPerm = new GlobalPermission(Collections.singletonList<method*start>java.util.Collections.singletonList<method*end>(GlobalPermission.ADMIN<method*start>org.apache.roller.weblogger.pojos.GlobalPermission.ADMIN<method*end>));
boolean hasAdmin = WebloggerFactory.getWeblogger<method*start>org.apache.roller.weblogger.business.WebloggerFactory.getWeblogger<method*end>().getUserManager<method*start>org.apache.roller.weblogger.business.Weblogger.getUserManager<method*end>().checkPermission<method*start>org.apache.roller.weblogger.business.UserManager.checkPermission<method*end>(adminPerm, pageRequest.getUser<method*start>org.apache.roller.weblogger.ui.rendering.util.ParsedRequest.getUser<method*end>());
return MenuHelper.getMenu<method*start>org.apache.roller.weblogger.ui.core.util.menu.MenuHelper.getMenu<method*end>("admin", "noAction", pageRequest.getUser<method*start>org.apache.roller.weblogger.ui.rendering.util.ParsedRequest.getUser<method*end>(), pageRequest.getWeblog<method*start>org.apache.roller.weblogger.ui.rendering.util.WeblogRequest.getWeblog<method*end>());
}
} catch (WebloggerException ex) {
logger.debug<method*start>org.apache.commons.logging.Log.debug<method*end>("ERROR: fetching user roles");
}
return null;
} | annotation | public Menu<method*start>org.apache.roller.weblogger.ui.core.util.menu.Menu<method*end> getAdminMenu() {
try {
GlobalPermission<method*start>org.apache.roller.weblogger.pojos.GlobalPermission<method*end> adminPerm = new GlobalPermission(Collections.singletonList<method*start>java.util.Collections.singletonList<method*end>(GlobalPermission.ADMIN<method*start>org.apache.roller.weblogger.pojos.GlobalPermission.ADMIN<method*end>));
boolean hasAdmin = WebloggerFactory.getWeblogger<method*start>org.apache.roller.weblogger.business.WebloggerFactory.getWeblogger<method*end>().getUserManager<method*start>org.apache.roller.weblogger.business.Weblogger.getUserManager<method*end>().checkPermission<method*start>org.apache.roller.weblogger.business.UserManager.checkPermission<method*end>(adminPerm, pageRequest.getUser<method*start>org.apache.roller.weblogger.ui.rendering.util.ParsedRequest.getUser<method*end>());
if (pageRequest.isLoggedIn<method*start>org.apache.roller.weblogger.ui.rendering.util.ParsedRequest.isLoggedIn<method*end>() && hasAdmin) {
return MenuHelper.getMenu<method*start>org.apache.roller.weblogger.ui.core.util.menu.MenuHelper.getMenu<method*end>("admin", "noAction", pageRequest.getUser<method*start>org.apache.roller.weblogger.ui.rendering.util.ParsedRequest.getUser<method*end>(), pageRequest.getWeblog<method*start>org.apache.roller.weblogger.ui.rendering.util.WeblogRequest.getWeblog<method*end>());
}
} catch (WebloggerException ex) {
logger.debug<method*start>org.apache.commons.logging.Log.debug<method*end>("ERROR: fetching user roles");
}
return null;
}
|
protected AbstractJcrNode getNode(String<method*start>java.lang.String<method*end> absPath, boolean accessControlScope) throws PathNotFoundException<method*start>javax.jcr.PathNotFoundException<method*end>, RepositoryException<method*start>javax.jcr.RepositoryException<method*end> {
checkLive<method*start>org.modeshape.jcr.JcrSession.checkLive<method*end>();
CheckArg.isNotEmpty<method*start>org.modeshape.common.util.CheckArg.isNotEmpty<method*end>(absPath, "absolutePath");
Path<method*start>org.modeshape.jcr.value.Path<method*end> path = absolutePathFor(absPath);
checkPermission<method*start>org.modeshape.jcr.JcrSession.checkPermission<method*end>(path, ModeShapePermissions.READ<method*start>org.modeshape.jcr.ModeShapePermissions.READ<method*end>);
}
// Return root node if path is "/" ...
return getRootNode();
}
return node(path);
}
| conventional | protected AbstractJcrNode getNode(String<method*start>java.lang.String<method*end> absPath, boolean accessControlScope) throws PathNotFoundException<method*start>javax.jcr.PathNotFoundException<method*end>, RepositoryException<method*start>javax.jcr.RepositoryException<method*end> {
checkLive<method*start>org.modeshape.jcr.JcrSession.checkLive<method*end>();
CheckArg.isNotEmpty<method*start>org.modeshape.common.util.CheckArg.isNotEmpty<method*end>(absPath, "absolutePath");
Path<method*start>org.modeshape.jcr.value.Path<method*end> path = absolutePathFor(absPath);
if (!accessControlScope) {
checkPermission<method*start>org.modeshape.jcr.JcrSession.checkPermission<method*end>(path, ModeShapePermissions.READ<method*start>org.modeshape.jcr.ModeShapePermissions.READ<method*end>);
}
// Return root node if path is "/" ...
if (path.isRoot<method*start>org.modeshape.jcr.value.Path.isRoot<method*end>()) {
return getRootNode();
}
return node(path);
}
|
public void removeNote(String<method*start>java.lang.String<method*end> noteId, ServiceContext<method*start>org.apache.zeppelin.service.ServiceContext<method*end> context, ServiceCallback<method*start>org.apache.zeppelin.service.ServiceCallback<method*end><String<method*start>java.lang.String<method*end>> callback) throws IOException<method*start>java.io.IOException<method*end> {
if (notebook.getNote<method*start>org.apache.zeppelin.notebook.Notebook.getNote<method*end>(noteId) != null) {
if (!checkPermission<method*start>org.apache.zeppelin.service.NotebookService.checkPermission<method*end>(noteId, Permission.OWNER<method*start>org.apache.zeppelin.service.NotebookService.Permission.OWNER<method*end>, Message.OP.DEL_NOTE<method*start>org.apache.zeppelin.notebook.socket.Message.OP.DEL_NOTE<method*end>, context, callback)) {
return;
}
callback.onSuccess<method*start>org.apache.zeppelin.service.ServiceCallback.onSuccess<method*end>("Delete note successfully", context);
} else {
callback.onFailure<method*start>org.apache.zeppelin.service.ServiceCallback.onFailure<method*end>(new NoteNotFoundException(noteId), context);
}
}
| conventional | public void removeNote(String<method*start>java.lang.String<method*end> noteId, ServiceContext<method*start>org.apache.zeppelin.service.ServiceContext<method*end> context, ServiceCallback<method*start>org.apache.zeppelin.service.ServiceCallback<method*end><String<method*start>java.lang.String<method*end>> callback) throws IOException<method*start>java.io.IOException<method*end> {
if (notebook.getNote<method*start>org.apache.zeppelin.notebook.Notebook.getNote<method*end>(noteId) != null) {
if (!checkPermission<method*start>org.apache.zeppelin.service.NotebookService.checkPermission<method*end>(noteId, Permission.OWNER<method*start>org.apache.zeppelin.service.NotebookService.Permission.OWNER<method*end>, Message.OP.DEL_NOTE<method*start>org.apache.zeppelin.notebook.socket.Message.OP.DEL_NOTE<method*end>, context, callback)) {
return;
}
notebook.removeNote<method*start>org.apache.zeppelin.notebook.Notebook.removeNote<method*end>(noteId, context.getAutheInfo<method*start>org.apache.zeppelin.service.ServiceContext.getAutheInfo<method*end>());
callback.onSuccess<method*start>org.apache.zeppelin.service.ServiceCallback.onSuccess<method*end>("Delete note successfully", context);
} else {
callback.onFailure<method*start>org.apache.zeppelin.service.ServiceCallback.onFailure<method*end>(new NoteNotFoundException(noteId), context);
}
}
|
public <S> S getService(ServiceReference<method*start>org.osgi.framework.ServiceReference<method*end><S> ref) {
if (ref == null) {
throw new NullPointerException<method*start>java.lang.NullPointerException<method*end>("Specified service reference cannot be null.");
}
return m_felix.getService<method*start>org.apache.felix.framework.Felix.getService<method*end>(m_bundle, ref, false);
} | conventional | public <S> S getService(ServiceReference<method*start>org.osgi.framework.ServiceReference<method*end><S> ref) {
checkValidity<method*start>org.apache.felix.framework.BundleContextImpl.checkValidity<method*end>();
if (ref == null) {
throw new NullPointerException<method*start>java.lang.NullPointerException<method*end>("Specified service reference cannot be null.");
}
Object<method*start>java.lang.Object<method*end> sm = System.getSecurityManager<method*start>java.lang.System.getSecurityManager<method*end>();
if (sm != null) {
((SecurityManager<method*start>java.lang.SecurityManager<method*end>) sm).checkPermission<method*start>java.lang.SecurityManager.checkPermission<method*end>(new ServicePermission<method*start>org.osgi.framework.ServicePermission<method*end>(ref, ServicePermission.GET<method*start>org.osgi.framework.ServicePermission.GET<method*end>));
}
return m_felix.getService<method*start>org.apache.felix.framework.Felix.getService<method*end>(m_bundle, ref, false);
}
|
@Override<method*start>java.lang.Override<method*end>
public boolean checkSubscriptionAdmin(String<method*start>java.lang.String<method*end> sessionId) throws NotConnectedRestException<method*start>org.ow2.proactive_grid_cloud_portal.scheduler.exception.NotConnectedRestException<method*end> {
Scheduler<method*start>org.ow2.proactive.scheduler.common.Scheduler<method*end> scheduler = checkAccess<method*start>org.ow2.proactive_grid_cloud_portal.common.CommonRest.checkAccess<method*end>(sessionId);
try {
} catch (PermissionException<method*start>org.ow2.proactive.scheduler.common.exception.PermissionException<method*end> e) {
return false;
} catch (NotConnectedException<method*start>org.ow2.proactive.scheduler.common.exception.NotConnectedException<method*end> e) {
throw new NotConnectedRestException<method*start>org.ow2.proactive_grid_cloud_portal.scheduler.exception.NotConnectedRestException<method*end>(YOU_ARE_NOT_CONNECTED_TO_THE_SCHEDULER_YOU_SHOULD_LOG_ON_FIRST);
}
} | annotation | @Override<method*start>java.lang.Override<method*end>
public boolean checkSubscriptionAdmin(String<method*start>java.lang.String<method*end> sessionId) throws NotConnectedRestException<method*start>org.ow2.proactive_grid_cloud_portal.scheduler.exception.NotConnectedRestException<method*end> {
Scheduler<method*start>org.ow2.proactive.scheduler.common.Scheduler<method*end> scheduler = checkAccess<method*start>org.ow2.proactive_grid_cloud_portal.common.CommonRest.checkAccess<method*end>(sessionId);
try {
return checkPermission<method*start>org.ow2.proactive_grid_cloud_portal.common.CommonRest.checkPermission<method*end>(scheduler.getSubject<method*start>org.ow2.proactive.scheduler.common.Scheduler.getSubject<method*end>(), new NotificationAdminPermission<method*start>org.ow2.proactive.permissions.NotificationAdminPermission<method*end>(), "User does not have notification service administrator privilege");
} catch (PermissionException<method*start>org.ow2.proactive.scheduler.common.exception.PermissionException<method*end> e) {
return false;
} catch (NotConnectedException<method*start>org.ow2.proactive.scheduler.common.exception.NotConnectedException<method*end> e) {
throw new NotConnectedRestException<method*start>org.ow2.proactive_grid_cloud_portal.scheduler.exception.NotConnectedRestException<method*end>(YOU_ARE_NOT_CONNECTED_TO_THE_SCHEDULER_YOU_SHOULD_LOG_ON_FIRST);
}
}
|
@Nonnull<method*start>javax.annotation.Nonnull<method*end>
@Override<method*start>java.lang.Override<method*end>
@CheckReturnValue<method*start>javax.annotation.CheckReturnValue<method*end>
public MessageActionImpl<method*start>net.dv8tion.jda.internal.requests.restaction.MessageActionImpl<method*end> addFile(@Nonnull<method*start>javax.annotation.Nonnull<method*end> final InputStream<method*start>java.io.InputStream<method*end> data, @Nonnull<method*start>javax.annotation.Nonnull<method*end> String name, @Nonnull<method*start>javax.annotation.Nonnull<method*end> AttachmentOption... options) {
Checks.notNull<method*start>net.dv8tion.jda.internal.utils.Checks.notNull<method*end>(data, "Data");
Checks.notBlank<method*start>net.dv8tion.jda.internal.utils.Checks.notBlank<method*end>(name, "Name");
Checks.noneNull<method*start>net.dv8tion.jda.internal.utils.Checks.noneNull<method*end>(options, "Options");
checkFileAmount<method*start>net.dv8tion.jda.internal.requests.restaction.MessageActionImpl.checkFileAmount<method*end>();
name = applyOptions<method*start>net.dv8tion.jda.internal.requests.restaction.MessageActionImpl.applyOptions<method*end>(name, options);
files.put<method*start>java.util.Map.put<method*end>(name, data);
return this;
} | annotation | @Nonnull<method*start>javax.annotation.Nonnull<method*end>
@Override<method*start>java.lang.Override<method*end>
@CheckReturnValue<method*start>javax.annotation.CheckReturnValue<method*end>
public MessageActionImpl<method*start>net.dv8tion.jda.internal.requests.restaction.MessageActionImpl<method*end> addFile(@Nonnull<method*start>javax.annotation.Nonnull<method*end> final InputStream<method*start>java.io.InputStream<method*end> data, @Nonnull<method*start>javax.annotation.Nonnull<method*end> String name, @Nonnull<method*start>javax.annotation.Nonnull<method*end> AttachmentOption... options) {
checkEdit<method*start>net.dv8tion.jda.internal.requests.restaction.MessageActionImpl.checkEdit<method*end>();
Checks.notNull<method*start>net.dv8tion.jda.internal.utils.Checks.notNull<method*end>(data, "Data");
Checks.notBlank<method*start>net.dv8tion.jda.internal.utils.Checks.notBlank<method*end>(name, "Name");
Checks.noneNull<method*start>net.dv8tion.jda.internal.utils.Checks.noneNull<method*end>(options, "Options");
checkFileAmount<method*start>net.dv8tion.jda.internal.requests.restaction.MessageActionImpl.checkFileAmount<method*end>();
checkPermission<method*start>net.dv8tion.jda.internal.requests.restaction.MessageActionImpl.checkPermission<method*end>(Permission.MESSAGE_ATTACH_FILES<method*start>net.dv8tion.jda.api.Permission.MESSAGE_ATTACH_FILES<method*end>);
name = applyOptions<method*start>net.dv8tion.jda.internal.requests.restaction.MessageActionImpl.applyOptions<method*end>(name, options);
files.put<method*start>java.util.Map.put<method*end>(name, data);
return this;
}
|
protected void removeItem(ItemImpl itemImpl) throws RepositoryException {
NodeImpl n;
if (itemImpl.isNode()) {
n = (NodeImpl) itemImpl;
} else {
n = (NodeImpl) itemImpl.getParent();
}
// validation: make sure Node is not locked or checked-in.
n.checkSetProperty();
itemImpl.perform(new ItemRemoveOperation(itemImpl, false));
} | conventional | protected void removeItem(ItemImpl<method*start>org.apache.jackrabbit.core.ItemImpl<method*end> itemImpl) throws RepositoryException<method*start>javax.jcr.RepositoryException<method*end> {
NodeImpl<method*start>org.apache.jackrabbit.core.NodeImpl<method*end> n;
if (itemImpl.isNode<method*start>org.apache.jackrabbit.core.ItemImpl.isNode<method*end>()) {
n = (NodeImpl<method*start>org.apache.jackrabbit.core.NodeImpl<method*end>) itemImpl;
} else {
n = (NodeImpl<method*start>org.apache.jackrabbit.core.NodeImpl<method*end>) itemImpl.getParent<method*start>org.apache.jackrabbit.core.ItemImpl.getParent<method*end>();
}
checkPermission<method*start>org.apache.jackrabbit.core.ProtectedItemModifier.checkPermission<method*end>(itemImpl, getPermission<method*start>org.apache.jackrabbit.core.ProtectedItemModifier.getPermission<method*end>(itemImpl.isNode<method*start>org.apache.jackrabbit.core.ItemImpl.isNode<method*end>(), true));
// validation: make sure Node is not locked or checked-in.
n.checkSetProperty<method*start>org.apache.jackrabbit.core.NodeImpl.checkSetProperty<method*end>();
itemImpl.perform<method*start>org.apache.jackrabbit.core.ItemImpl.perform<method*end>(new ItemRemoveOperation<method*start>org.apache.jackrabbit.core.ItemRemoveOperation<method*end>(itemImpl, false));
}
|
public RetentionPolicy<method*start>javax.jcr.retention.RetentionPolicy<method*end> getRetentionPolicy(String<method*start>java.lang.String<method*end> absPath) throws PathNotFoundException<method*start>javax.jcr.PathNotFoundException<method*end>, AccessDeniedException<method*start>javax.jcr.AccessDeniedException<method*end>, RepositoryException<method*start>javax.jcr.RepositoryException<method*end> {
NodeImpl<method*start>org.apache.jackrabbit.core.NodeImpl<method*end> n = (NodeImpl<method*start>org.apache.jackrabbit.core.NodeImpl<method*end>) session.getNode<method*start>org.apache.jackrabbit.core.SessionImpl.getNode<method*end>(absPath);
RetentionPolicy<method*start>javax.jcr.retention.RetentionPolicy<method*end> rPolicy = null;
if (n.isNodeType<method*start>org.apache.jackrabbit.core.NodeImpl.isNodeType<method*end>(REP_RETENTION_MANAGEABLE) && n.hasProperty<method*start>org.apache.jackrabbit.core.NodeImpl.hasProperty<method*end>(REP_RETENTION_POLICY)) {
String<method*start>java.lang.String<method*end> jcrName = n.getProperty<method*start>org.apache.jackrabbit.core.NodeImpl.getProperty<method*end>(REP_RETENTION_POLICY).getString<method*start>org.apache.jackrabbit.core.PropertyImpl.getString<method*end>();
rPolicy = new RetentionPolicyImpl<method*start>org.apache.jackrabbit.core.retention.RetentionPolicyImpl<method*end>(jcrName, n.getNodeId<method*start>org.apache.jackrabbit.core.NodeImpl.getNodeId<method*end>(), session);
}
return rPolicy;
}
| conventional | public RetentionPolicy<method*start>javax.jcr.retention.RetentionPolicy<method*end> getRetentionPolicy(String<method*start>java.lang.String<method*end> absPath) throws PathNotFoundException<method*start>javax.jcr.PathNotFoundException<method*end>, AccessDeniedException<method*start>javax.jcr.AccessDeniedException<method*end>, RepositoryException<method*start>javax.jcr.RepositoryException<method*end> {
NodeImpl<method*start>org.apache.jackrabbit.core.NodeImpl<method*end> n = (NodeImpl<method*start>org.apache.jackrabbit.core.NodeImpl<method*end>) session.getNode<method*start>org.apache.jackrabbit.core.SessionImpl.getNode<method*end>(absPath);
session.getAccessManager<method*start>org.apache.jackrabbit.core.SessionImpl.getAccessManager<method*end>().checkPermission<method*start>org.apache.jackrabbit.core.security.AccessManager.checkPermission<method*end>(session.getQPath<method*start>org.apache.jackrabbit.core.SessionImpl.getQPath<method*end>(absPath), Permission.RETENTION_MNGMT<method*start>org.apache.jackrabbit.core.security.authorization.Permission.RETENTION_MNGMT<method*end>);
RetentionPolicy<method*start>javax.jcr.retention.RetentionPolicy<method*end> rPolicy = null;
if (n.isNodeType<method*start>org.apache.jackrabbit.core.NodeImpl.isNodeType<method*end>(REP_RETENTION_MANAGEABLE) && n.hasProperty<method*start>org.apache.jackrabbit.core.NodeImpl.hasProperty<method*end>(REP_RETENTION_POLICY)) {
String<method*start>java.lang.String<method*end> jcrName = n.getProperty<method*start>org.apache.jackrabbit.core.NodeImpl.getProperty<method*end>(REP_RETENTION_POLICY).getString<method*start>org.apache.jackrabbit.core.PropertyImpl.getString<method*end>();
rPolicy = new RetentionPolicyImpl<method*start>org.apache.jackrabbit.core.retention.RetentionPolicyImpl<method*end>(jcrName, n.getNodeId<method*start>org.apache.jackrabbit.core.NodeImpl.getNodeId<method*end>(), session);
}
return rPolicy;
}
|
public Note<method*start>org.apache.zeppelin.notebook.Note<method*end> getHomeNote(ServiceContext<method*start>org.apache.zeppelin.service.ServiceContext<method*end> context, ServiceCallback<method*start>org.apache.zeppelin.service.ServiceCallback<method*end><Note<method*start>org.apache.zeppelin.notebook.Note<method*end>> callback) throws IOException<method*start>java.io.IOException<method*end> {
String<method*start>java.lang.String<method*end> noteId = notebook.getConf<method*start>org.apache.zeppelin.notebook.Notebook.getConf<method*end>().getString<method*start>org.apache.zeppelin.conf.ZeppelinConfiguration.getString<method*end>(ZEPPELIN_NOTEBOOK_HOMESCREEN<method*start>org.apache.zeppelin.conf.ZeppelinConfiguration.ConfVars.ZEPPELIN_NOTEBOOK_HOMESCREEN<method*end>);
Note<method*start>org.apache.zeppelin.notebook.Note<method*end> note = null;
if (noteId != null) {
note = notebook.getNote<method*start>org.apache.zeppelin.notebook.Notebook.getNote<method*end>(noteId);
if (note != null) {
return null;
}
}
callback.onSuccess<method*start>org.apache.zeppelin.service.ServiceCallback.onSuccess<method*end>(note, context);
return note;
} | conventional | public Note<method*start>org.apache.zeppelin.notebook.Note<method*end> getHomeNote(ServiceContext<method*start>org.apache.zeppelin.service.ServiceContext<method*end> context, ServiceCallback<method*start>org.apache.zeppelin.service.ServiceCallback<method*end><Note<method*start>org.apache.zeppelin.notebook.Note<method*end>> callback) throws IOException<method*start>java.io.IOException<method*end> {
String<method*start>java.lang.String<method*end> noteId = notebook.getConf<method*start>org.apache.zeppelin.notebook.Notebook.getConf<method*end>().getString<method*start>org.apache.zeppelin.conf.ZeppelinConfiguration.getString<method*end>(ZEPPELIN_NOTEBOOK_HOMESCREEN<method*start>org.apache.zeppelin.conf.ZeppelinConfiguration.ConfVars.ZEPPELIN_NOTEBOOK_HOMESCREEN<method*end>);
Note<method*start>org.apache.zeppelin.notebook.Note<method*end> note = null;
if (noteId != null) {
note = notebook.getNote<method*start>org.apache.zeppelin.notebook.Notebook.getNote<method*end>(noteId);
if (note != null) {
if (!checkPermission<method*start>org.apache.zeppelin.service.NotebookService.checkPermission<method*end>(noteId, Permission.READER<method*start>org.apache.zeppelin.service.NotebookService.Permission.READER<method*end>, Message.OP.GET_HOME_NOTE<method*start>org.apache.zeppelin.notebook.socket.Message.OP.GET_HOME_NOTE<method*end>, context, callback)) {
return null;
}
}
}
callback.onSuccess<method*start>org.apache.zeppelin.service.ServiceCallback.onSuccess<method*end>(note, context);
return note;
}
|
@Override
public boolean isActionAuthorized(Component<method*start>org.apache.wicket.Component<method*end> component, Action<method*start>org.apache.wicket.authorization.Action<method*end> action) {
if (component instanceof RestrictedComponent<method*start>org.jabylon.rest.ui.security.RestrictedComponent<method*end>) {
RestrictedComponent<method*start>org.jabylon.rest.ui.security.RestrictedComponent<method*end> restricted = (RestrictedComponent<method*start>org.jabylon.rest.ui.security.RestrictedComponent<method*end>) component;
String<method*start>java.lang.String<method*end> permission = restricted.getRequiredPermission<method*start>org.jabylon.rest.ui.security.RestrictedComponent.getRequiredPermission<method*end>();
CDOAuthenticatedSession<method*start>org.jabylon.rest.ui.security.CDOAuthenticatedSession<method*end> session = (CDOAuthenticatedSession<method*start>org.jabylon.rest.ui.security.CDOAuthenticatedSession<method*end>) CDOAuthenticatedSession.get<method*start>org.apache.wicket.authroles.authentication.AuthenticatedWebSession.get<method*end>();
if (session.getUser<method*start>org.jabylon.rest.ui.security.CDOAuthenticatedSession.getUser<method*end>() == null) {
User<method*start>org.jabylon.users.User<method*end> anonymousUser = session.getAnonymousUser<method*start>org.jabylon.rest.ui.security.CDOAuthenticatedSession.getAnonymousUser<method*end>();
if (anonymousUser == null)
return false;
boolean allowed = anonymousUser.hasPermission<method*start>org.jabylon.users.User.hasPermission<method*end>(permission);
throw new RestartResponseAtInterceptPageException<method*start>org.apache.wicket.RestartResponseAtInterceptPageException<method*end>(LoginPage<method*start>org.jabylon.rest.ui.security.LoginPage<method*end>.class);
}
boolean allowed = session.getUser<method*start>org.jabylon.rest.ui.security.CDOAuthenticatedSession.getUser<method*end>().hasPermission<method*start>org.jabylon.users.User.hasPermission<method*end>(permission);
if (CommonPermissions.isEditRequest<method*start>org.jabylon.security.CommonPermissions.isEditRequest<method*end>(permission))
throw new UnauthorizedActionException<method*start>org.apache.wicket.authorization.UnauthorizedActionException<method*end>(component, action);
return false;
}
return true;
} | annotation | @Override
public boolean isActionAuthorized(Component<method*start>org.apache.wicket.Component<method*end> component, Action<method*start>org.apache.wicket.authorization.Action<method*end> action) {
if (component instanceof RestrictedComponent<method*start>org.jabylon.rest.ui.security.RestrictedComponent<method*end>) {
RestrictedComponent<method*start>org.jabylon.rest.ui.security.RestrictedComponent<method*end> restricted = (RestrictedComponent<method*start>org.jabylon.rest.ui.security.RestrictedComponent<method*end>) component;
String<method*start>java.lang.String<method*end> permission = restricted.getRequiredPermission<method*start>org.jabylon.rest.ui.security.RestrictedComponent.getRequiredPermission<method*end>();
if (permission == null)
return true;
CDOAuthenticatedSession<method*start>org.jabylon.rest.ui.security.CDOAuthenticatedSession<method*end> session = (CDOAuthenticatedSession<method*start>org.jabylon.rest.ui.security.CDOAuthenticatedSession<method*end>) CDOAuthenticatedSession.get<method*start>org.apache.wicket.authroles.authentication.AuthenticatedWebSession.get<method*end>();
if (session.getUser<method*start>org.jabylon.rest.ui.security.CDOAuthenticatedSession.getUser<method*end>() == null) {
User<method*start>org.jabylon.users.User<method*end> anonymousUser = session.getAnonymousUser<method*start>org.jabylon.rest.ui.security.CDOAuthenticatedSession.getAnonymousUser<method*end>();
if (anonymousUser == null)
return false;
boolean allowed = anonymousUser.hasPermission<method*start>org.jabylon.users.User.hasPermission<method*end>(permission);
if (allowed)
return true;
throw new RestartResponseAtInterceptPageException<method*start>org.apache.wicket.RestartResponseAtInterceptPageException<method*end>(LoginPage<method*start>org.jabylon.rest.ui.security.LoginPage<method*end>.class);
}
boolean allowed = session.getUser<method*start>org.jabylon.rest.ui.security.CDOAuthenticatedSession.getUser<method*end>().hasPermission<method*start>org.jabylon.users.User.hasPermission<method*end>(permission);
if (allowed)
return true;
if (CommonPermissions.isEditRequest<method*start>org.jabylon.security.CommonPermissions.isEditRequest<method*end>(permission))
throw new UnauthorizedActionException<method*start>org.apache.wicket.authorization.UnauthorizedActionException<method*end>(component, action);
return false;
}
return true;
}
|
protected int classLoaderDepth() {
try
{
}
catch (SecurityException e)
{
Class[] c = VMStackWalker.getClassContext();
for (int i = 1; i < c.length; i++)
if (c[i].getClassLoader() != null)
// XXX Check if c[i] is AccessController, or a system class.
return i - 1;
}
return -1;
} | conventional | protected int classLoaderDepth() {
/* try
{
checkPermission(new AllPermission());
}
catch (SecurityException e)
{
Class[] c = VMStackWalker.getClassContext();
for (int i = 1; i < c.length; i++)
if (c[i].getClassLoader() != null)
// XXX Check if c[i] is AccessController, or a system class.
return i - 1;
} */
return -1;
}
|
protected int classLoaderDepth() {
Class[] c = getClassContext();
for (int i = 0; i < c.length; i++) if (c[i].getClassLoader() != null)
// XXX Check if c[i] is AccessController, or a system class.
return i;
}
return -1;
} | conventional | protected int classLoaderDepth() {
try {
checkPermission<method*start>java.lang.SecurityManager.checkPermission<method*end>(new AllPermission<method*start>java.security.AllPermission<method*end>());
} catch (SecurityException e) {
Class[] c = getClassContext();
for (int i = 0; i < c.length<method*start>java.lang.Class[].length<method*end>; i++) if (c[i].getClassLoader<method*start>java.lang.Class.getClassLoader<method*end>() != null)
// XXX Check if c[i] is AccessController, or a system class.
return i;
}
return -1;
}
|
public ChatChannel createNewChannel(String context, String title, boolean placementDefaultChannel, boolean checkAuthz, String placement) throws PermissionException {
ChatChannel channel = new ChatChannel(getDefaultChannelSettings());
channel.setCreationDate(new Date());
channel.setContext(context);
channel.setTitle(title);
channel.setPlacementDefaultChannel(placementDefaultChannel);
if (placementDefaultChannel) {
channel.setPlacement(placement);
}
return channel;
} | conventional | public ChatChannel<method*start>org.sakaiproject.chat2.model.ChatChannel<method*end> createNewChannel(String<method*start>java.lang.String<method*end> context, String<method*start>java.lang.String<method*end> title, boolean placementDefaultChannel, boolean checkAuthz, String<method*start>java.lang.String<method*end> placement) throws PermissionException<method*start>org.sakaiproject.exception.PermissionException<method*end> {
if (checkAuthz)
checkPermission<method*start>org.sakaiproject.chat2.model.impl.ChatManagerImpl.checkPermission<method*end>(ChatFunctions.CHAT_FUNCTION_NEW_CHANNEL, context);
ChatChannel<method*start>org.sakaiproject.chat2.model.ChatChannel<method*end> channel = new ChatChannel<method*start>org.sakaiproject.chat2.model.ChatChannel<method*end>(getDefaultChannelSettings<method*start>org.sakaiproject.chat2.model.impl.ChatManagerImpl.getDefaultChannelSettings<method*end>());
channel.setCreationDate(new Date<method*start>java.util.Date<method*end>());
channel.setContext(context);
channel.setTitle(title);
channel.setPlacementDefaultChannel(placementDefaultChannel);
if (placementDefaultChannel) {
channel.setPlacement(placement);
}
return channel;
}
|
public static void main(String[] args) {
Order<com.xpinjection.patterns.proxy.canonical.Order> order = new Order<com.xpinjection.patterns.proxy.canonical.Order>(5L);
order.putItem<com.xpinjection.patterns.proxy.canonical.Order.putItem>("XP", 2);
RealOrderService<com.xpinjection.patterns.proxy.canonical.RealOrderService> service = new RealOrderService<com.xpinjection.patterns.proxy.canonical.RealOrderService>();
} | annotation | public static void main(String<method*start>java.lang.String<method*end>[] args) {
Order<method*start>com.xpinjection.patterns.proxy.canonical.Order<method*end> order = new Order<method*start>com.xpinjection.patterns.proxy.canonical.Order<method*end>(5L);
order.putItem<method*start>com.xpinjection.patterns.proxy.canonical.Order.putItem<method*end>("XP", 2);
RealOrderService<method*start>com.xpinjection.patterns.proxy.canonical.RealOrderService<method*end> service = new RealOrderService<method*start>com.xpinjection.patterns.proxy.canonical.RealOrderService<method*end>();
PermissionChecker<method*start>com.xpinjection.patterns.proxy.PermissionChecker<method*end> checker = new PermissionChecker<method*start>com.xpinjection.patterns.proxy.PermissionChecker<method*end>();
Consumer<method*start>java.util.function.Consumer<method*end><Order<method*start>com.xpinjection.patterns.proxy.canonical.Order<method*end>> processing = ((Consumer<method*start>java.util.function.Consumer<method*end><Order<method*start>com.xpinjection.patterns.proxy.canonical.Order<method*end>>) checker::checkPermission).andThen<method*start>java.util.function.Consumer.andThen<method*end>(service::processOrder);
checker.setCurrentUser<method*start>com.xpinjection.patterns.proxy.PermissionChecker.setCurrentUser<method*end>(5);
processing.accept<method*start>java.util.function.Consumer.accept<method*end>(order);
checker.setCurrentUser<method*start>com.xpinjection.patterns.proxy.PermissionChecker.setCurrentUser<method*end>(2);
processing.accept<method*start>java.util.function.Consumer.accept<method*end>(order);
}
|
public int hasUserDataPermission(HttpServletRequest httpsr, String uri, String httpMethod) {
setSecurityInfo(httpsr);
WebUserDataPermission perm;
boolean requestIsSecure = httpsr.isSecure();
boolean isGranted = checkPermission(perm, defaultPrincipalSet);
int result = 0;
if (logger.isLoggable(Level.FINE)) {
logger.log(Level.FINE, "[Web-Security] hasUserDataPermission perm: {0}", perm);
logger.log(Level.FINE, "[Web-Security] hasUserDataPermission isGranted: {0}", isGranted);
}
recordWebInvocation(httpsr, USERDATA, isGranted);
if (!isGranted && !requestIsSecure) {
if (uri == null) {
httpMethod = httpsr.getMethod();
}
perm = new WebUserDataPermission(perm.getName(), httpMethod == null ? null : new String[] { httpMethod }, "CONFIDENTIAL");
isGranted = checkPermission(perm, defaultPrincipalSet);
return result;
} | conventional | public int hasUserDataPermission(HttpServletRequest<method*start>javax.servlet.http.HttpServletRequest<method*end> httpsr, String<method*start>java.lang.String<method*end> uri, String<method*start>java.lang.String<method*end> httpMethod) {
setSecurityInfo<method*start>com.sun.enterprise.security.web.integration.WebSecurityManager.setSecurityInfo<method*end>(httpsr);
WebUserDataPermission<method*start>javax.security.jacc.WebUserDataPermission<method*end> perm;
boolean requestIsSecure = httpsr.isSecure<method*start>javax.servlet.http.HttpServletRequest.isSecure<method*end>();
if (uri == null) {
perm = new WebUserDataPermission<method*start>javax.security.jacc.WebUserDataPermission<method*end>(httpsr);
} else {
perm = new WebUserDataPermission<method*start>javax.security.jacc.WebUserDataPermission<method*end>(uri, httpMethod == null ? null : new String<method*start>java.lang.String<method*end>[] { httpMethod }, requestIsSecure ? "CONFIDENTIAL" : null);
}
boolean isGranted = checkPermission(perm, defaultPrincipalSet);
int result = 0;
if (isGranted) {
result = 1;
}
if (logger.isLoggable<method*start>java.util.logging.Logger.isLoggable<method*end>(Level.FINE<method*start>java.util.logging.Level.FINE<method*end>)) {
logger.log<method*start>java.util.logging.Logger.log<method*end>(Level.FINE<method*start>java.util.logging.Level.FINE<method*end>, "[Web-Security] hasUserDataPermission perm: {0}", perm);
logger.log<method*start>java.util.logging.Logger.log<method*end>(Level.FINE<method*start>java.util.logging.Level.FINE<method*end>, "[Web-Security] hasUserDataPermission isGranted: {0}", isGranted);
}
recordWebInvocation<method*start>com.sun.enterprise.security.web.integration.WebSecurityManager.recordWebInvocation<method*end>(httpsr, USERDATA, isGranted);
if (!isGranted && !requestIsSecure) {
if (uri == null) {
httpMethod = httpsr.getMethod<method*start>javax.servlet.http.HttpServletRequest.getMethod<method*end>();
}
perm = new WebUserDataPermission<method*start>javax.security.jacc.WebUserDataPermission<method*end>(perm.getName<method*start>javax.security.jacc.WebUserDataPermission.getName<method*end>(), httpMethod == null ? null : new String<method*start>java.lang.String<method*end>[] { httpMethod }, "CONFIDENTIAL");
isGranted = checkPermission(perm, defaultPrincipalSet);
if (isGranted)
result = -1;
}
return result;
}
|
public void updatePersonalizedMode(String noteId, boolean isPersonalized, ServiceContext context, ServiceCallback<Note> callback) throws IOException {
Note note = notebook.getNote(noteId);
if (note == null) {
callback.onFailure(new NoteNotFoundException(noteId), context);
return;
}
note.setPersonalizedMode(isPersonalized);
notebook.saveNote(note, context.getAutheInfo());
callback.onSuccess(note, context);
} | conventional | public void updatePersonalizedMode(String<method*start>java.lang.String<method*end> noteId, boolean isPersonalized, ServiceContext<method*start>org.apache.zeppelin.service.ServiceContext<method*end> context, ServiceCallback<method*start>org.apache.zeppelin.service.ServiceCallback<method*end><Note<method*start>org.apache.zeppelin.notebook.Note<method*end>> callback) throws IOException<method*start>java.io.IOException<method*end> {
Note<method*start>org.apache.zeppelin.notebook.Note<method*end> note = notebook.getNote<method*start>org.apache.zeppelin.notebook.Notebook.getNote<method*end>(noteId);
if (note == null) {
callback.onFailure<method*start>org.apache.zeppelin.service.ServiceCallback.onFailure<method*end>(new NoteNotFoundException(noteId), context);
return;
}
if (!checkPermission<method*start>org.apache.zeppelin.service.NotebookService.checkPermission<method*end>(noteId, Permission.WRITER<method*start>org.apache.zeppelin.service.NotebookService.Permission.WRITER<method*end>, Message.OP.UPDATE_PERSONALIZED_MODE<method*start>org.apache.zeppelin.notebook.socket.Message.OP.UPDATE_PERSONALIZED_MODE<method*end>, context, callback)) {
return;
}
note.setPersonalizedMode<method*start>org.apache.zeppelin.notebook.Note.setPersonalizedMode<method*end>(isPersonalized);
notebook.saveNote<method*start>org.apache.zeppelin.notebook.Notebook.saveNote<method*end>(note, context.getAutheInfo<method*start>org.apache.zeppelin.service.ServiceContext.getAutheInfo<method*end>());
callback.onSuccess<method*start>org.apache.zeppelin.service.ServiceCallback.onSuccess<method*end>(note, context);
}
|
@Override
public Bundle call(@NonNull String method, @Nullable String arg, @Nullable Bundle extras) {
if (arg == null || extras == null) {
return null;
}
if (TRANSFER_PROVIDER_METHOD_PUT.equals(method)) {
return handlePut(arg, extras);
} else if (TRANSFER_PROVIDER_METHOD_GET.equals(method)) {
return handleGet(arg, extras);
}
return null;
} | annotation | @Nullable<method*start>androidx.annotation.Nullable<method*end>
@Override<method*start>java.lang.Override<method*end>
public Bundle<method*start>android.os.Bundle<method*end> call(@NonNull<method*start>androidx.annotation.NonNull<method*end> String method, @Nullable<method*start>androidx.annotation.Nullable<method*end> String arg, @Nullable<method*start>androidx.annotation.Nullable<method*end> Bundle extras) {
if (arg == null || extras == null) {
return null;
}
if (!checkPermission<method*start>moe.shizuku.manager.legacy.provider.TransferProvider.checkPermission<method*end>()) {
return null;
}
if (TRANSFER_PROVIDER_METHOD_PUT.equals<method*start>java.lang.String.equals<method*end>(method)) {
return handlePut<method*start>moe.shizuku.manager.legacy.provider.TransferProvider.handlePut<method*end>(arg, extras);
} else if (TRANSFER_PROVIDER_METHOD_GET.equals<method*start>java.lang.String.equals<method*end>(method)) {
return handleGet<method*start>moe.shizuku.manager.legacy.provider.TransferProvider.handleGet<method*end>(arg, extras);
}
return null;
}
|
@Override
public AccessControlPolicyIterator<javax.jcr.security.AccessControlPolicyIterator> getApplicablePolicies(String absPath) throws PathNotFoundException, AccessDeniedException, RepositoryException {
checkInitialized();
if (editor != null) {
try {
AccessControlPolicy[] applicable = editor.editAccessControlPolicies(absPath);
return new AccessControlPolicyIteratorAdapter(Arrays.asList(applicable));
} catch (AccessControlException e) {
log.debug("No applicable policy at " + absPath);
}
}
// no applicable policies -> return empty iterator.
return AccessControlPolicyIteratorAdapter.EMPTY;
} | annotation | @Override<method*start>java.lang.Override<method*end>
public AccessControlPolicyIterator<method*start>javax.jcr.security.AccessControlPolicyIterator<method*end> getApplicablePolicies(String<method*start>java.lang.String<method*end> absPath) throws PathNotFoundException<method*start>javax.jcr.PathNotFoundException<method*end>, AccessDeniedException<method*start>javax.jcr.AccessDeniedException<method*end>, RepositoryException<method*start>javax.jcr.RepositoryException<method*end> {
checkInitialized<method*start>org.apache.jackrabbit.core.security.DefaultAccessManager.checkInitialized<method*end>();
checkPermission(absPath, Permission.READ_AC<method*start>org.apache.jackrabbit.core.security.authorization.Permission.READ_AC<method*end>);
if (editor != null) {
try {
AccessControlPolicy<method*start>javax.jcr.security.AccessControlPolicy<method*end>[] applicable = editor.editAccessControlPolicies<method*start>org.apache.jackrabbit.core.security.authorization.AccessControlEditor.editAccessControlPolicies<method*end>(absPath);
return new AccessControlPolicyIteratorAdapter<method*start>org.apache.jackrabbit.commons.iterator.AccessControlPolicyIteratorAdapter<method*end>(Arrays.asList<method*start>java.util.Arrays.asList<method*end>(applicable));
} catch (AccessControlException<method*start>javax.jcr.security.AccessControlException<method*end> e) {
log.debug<method*start>org.slf4j.Logger.debug<method*end>("No applicable policy at " + absPath);
}
}
// no applicable policies -> return empty iterator.
return AccessControlPolicyIteratorAdapter.EMPTY<method*start>org.apache.jackrabbit.commons.iterator.AccessControlPolicyIteratorAdapter.EMPTY<method*end>;
}
|
public void saveNoteForms(String noteId, Map noteParams, ServiceContext context, ServiceCallback callback) throws IOException {
Note note = notebook.getNote(noteId);
if (note == null) {
callback.onFailure(new NoteNotFoundException(noteId), context);
return;
}
note.setNoteParams(noteParams);
notebook.saveNote(note, context.getAutheInfo());
callback.onSuccess(note, context);
} | conventional | public void saveNoteForms(String<method*start>java.lang.String<method*end> noteId, Map<method*start>java.util.Map<method*end><String<method*start>java.lang.String<method*end>, Object<method*start>java.lang.Object<method*end>> noteParams, ServiceContext<method*start>org.apache.zeppelin.service.ServiceContext<method*end> context, ServiceCallback<method*start>org.apache.zeppelin.service.ServiceCallback<method*end><Note<method*start>org.apache.zeppelin.notebook.Note<method*end>> callback) throws IOException<method*start>java.io.IOException<method*end> {
if (!checkPermission<method*start>org.apache.zeppelin.service.NotebookService.checkPermission<method*end>(noteId, Permission.WRITER<method*start>org.apache.zeppelin.service.NotebookService.Permission.WRITER<method*end>, Message.OP.SAVE_NOTE_FORMS<method*start>org.apache.zeppelin.notebook.socket.Message.OP.SAVE_NOTE_FORMS<method*end>, context, callback)) {
return;
}
Note<method*start>org.apache.zeppelin.notebook.Note<method*end> note = notebook.getNote<method*start>org.apache.zeppelin.notebook.Notebook.getNote<method*end>(noteId);
if (note == null) {
callback.onFailure<method*start>org.apache.zeppelin.service.ServiceCallback.onFailure<method*end>(new NoteNotFoundException(noteId), context);
return;
}
note.setNoteParams<method*start>org.apache.zeppelin.notebook.Note.setNoteParams<method*end>(noteParams);
notebook.saveNote<method*start>org.apache.zeppelin.notebook.Notebook.saveNote<method*end>(note, context.getAutheInfo<method*start>org.apache.zeppelin.service.ServiceContext.getAutheInfo<method*end>());
callback.onSuccess<method*start>org.apache.zeppelin.service.ServiceCallback.onSuccess<method*end>(note, context);
}
|
public int broadcast(String<method*start>java.lang.String<method*end> message, String<method*start>java.lang.String<method*end> permissions) {
Set<method*start>java.util.Set<method*end><CommandSender<method*start>cn.nukkit.command.CommandSender<method*end>> recipients = new HashSet<method*start>java.util.HashSet<method*end><>();
for (String<method*start>java.lang.String<method*end> permission : permissions.split<method*start>java.lang.String.split<method*end>(";")) {
for (Permissible<method*start>cn.nukkit.permission.Permissible<method*end> permissible : this.pluginManager.getPermissionSubscriptions<method*start>cn.nukkit.plugin.PluginManager.getPermissionSubscriptions<method*end>(permission)) {
recipients.add<method*start>java.util.Set.add<method*end>((CommandSender<method*start>cn.nukkit.command.CommandSender<method*end>) permissible);
}
}
}
for (CommandSender<method*start>cn.nukkit.command.CommandSender<method*end> recipient : recipients) {
recipient.sendMessage<method*start>cn.nukkit.command.CommandSender.sendMessage<method*end>(message);
}
return recipients.size<method*start>java.util.Set.size<method*end>();
}
| conventional | public int broadcast(String<method*start>java.lang.String<method*end> message, String<method*start>java.lang.String<method*end> permissions) {
Set<method*start>java.util.Set<method*end><CommandSender<method*start>cn.nukkit.command.CommandSender<method*end>> recipients = new HashSet<method*start>java.util.HashSet<method*end><>();
for (String<method*start>java.lang.String<method*end> permission : permissions.split<method*start>java.lang.String.split<method*end>(";")) {
for (Permissible<method*start>cn.nukkit.permission.Permissible<method*end> permissible : this.pluginManager.getPermissionSubscriptions<method*start>cn.nukkit.plugin.PluginManager.getPermissionSubscriptions<method*end>(permission)) {
if (permissible instanceof CommandSender<method*start>cn.nukkit.command.CommandSender<method*end> && permissible.hasPermission<method*start>cn.nukkit.permission.Permissible.hasPermission<method*end>(permission)) {
recipients.add<method*start>java.util.Set.add<method*end>((CommandSender<method*start>cn.nukkit.command.CommandSender<method*end>) permissible);
}
}
}
for (CommandSender<method*start>cn.nukkit.command.CommandSender<method*end> recipient : recipients) {
recipient.sendMessage<method*start>cn.nukkit.command.CommandSender.sendMessage<method*end>(message);
}
return recipients.size<method*start>java.util.Set.size<method*end>();
}
|
public void removeCert(CmpRequestorInfo<method*start>org.xipki.ca.api.mgmt.RequestorInfo.CmpRequestorInfo<method*end> requestor, BigInteger<method*start>java.math.BigInteger<method*end> serialNumber, RequestType<method*start>org.xipki.ca.api.RequestType<method*end> reqType, String<method*start>java.lang.String<method*end> msgId) throws OperationException<method*start>org.xipki.ca.api.OperationException<method*end> {
Args.notNull<method*start>org.xipki.util.Args.notNull<method*end>(requestor, "requestor");
try {
} catch (InsuffientPermissionException ex) {
throw new OperationException<method*start>org.xipki.ca.api.OperationException<method*end>(ErrorCode.NOT_PERMITTED<method*start>org.xipki.ca.api.OperationException.ErrorCode.NOT_PERMITTED<method*end>, ex.getMessage<method*start>java.lang.Exception.getMessage<method*end>());
}
CertWithDbId returnedObj = getCa().removeCert<method*start>org.xipki.ca.server.X509Ca.removeCert<method*end>(serialNumber, msgId);
if (returnedObj == null) {
throw new OperationException<method*start>org.xipki.ca.api.OperationException<method*end>(ErrorCode.UNKNOWN_CERT<method*start>org.xipki.ca.api.OperationException.ErrorCode.UNKNOWN_CERT<method*end>, "cert not exists");
}
} | conventional | public void removeCert(CmpRequestorInfo<method*start>org.xipki.ca.api.mgmt.RequestorInfo.CmpRequestorInfo<method*end> requestor, BigInteger<method*start>java.math.BigInteger<method*end> serialNumber, RequestType<method*start>org.xipki.ca.api.RequestType<method*end> reqType, String<method*start>java.lang.String<method*end> msgId) throws OperationException<method*start>org.xipki.ca.api.OperationException<method*end> {
Args.notNull<method*start>org.xipki.util.Args.notNull<method*end>(requestor, "requestor");
try {
checkPermission(requestor, PermissionConstants.REMOVE_CERT<method*start>org.xipki.ca.api.mgmt.PermissionConstants.REMOVE_CERT<method*end>);
} catch (InsuffientPermissionException ex) {
throw new OperationException<method*start>org.xipki.ca.api.OperationException<method*end>(ErrorCode.NOT_PERMITTED<method*start>org.xipki.ca.api.OperationException.ErrorCode.NOT_PERMITTED<method*end>, ex.getMessage<method*start>java.lang.Exception.getMessage<method*end>());
}
CertWithDbId returnedObj = getCa().removeCert<method*start>org.xipki.ca.server.X509Ca.removeCert<method*end>(serialNumber, msgId);
if (returnedObj == null) {
throw new OperationException<method*start>org.xipki.ca.api.OperationException<method*end>(ErrorCode.UNKNOWN_CERT<method*start>org.xipki.ca.api.OperationException.ErrorCode.UNKNOWN_CERT<method*end>, "cert not exists");
}
}
|
public void requestPermissions(@NonNull<method*start>android.support.annotation.NonNull<method*end> CharSequence hintMessage, @Nullable<method*start>android.support.annotation.Nullable<method*end> PermissionListener listener, @NonNull<method*start>android.support.annotation.NonNull<method*end> final String<method*start>java.lang.String<method*end>... permissions) {
if (listener != null) {
mListener<method*start>com.cxz.baselibs.utils.PermissionHelper.mListener<method*end> = listener;
}
mPermissionList<method*start>com.cxz.baselibs.utils.PermissionHelper.mPermissionList<method*end> = Arrays.asList<method*start>java.util.Arrays.asList<method*end>(permissions);
// 需要向用户解释为什么申请这个权限
boolean shouldShowRationale = false;
for (String<method*start>java.lang.String<method*end> perm : permissions) {
shouldShowRationale = shouldShowRationale || shouldShowRequestPermissionRationale<method*start>com.cxz.baselibs.utils.PermissionHelper.shouldShowRequestPermissionRationale<method*end>(mContext, perm);
}
executePermissionsRequest<method*start>com.cxz.baselibs.utils.PermissionHelper.executePermissionsRequest<method*end>(mContext, permissions, REQUEST_PERMISSION_CODE);
mListener.doAfterGrand<method*start>com.cxz.baselibs.utils.PermissionHelper.PermissionListener.doAfterGrand<method*end>(permissions);
}
} | conventional | public void requestPermissions(@NonNull<method*start>android.support.annotation.NonNull<method*end> CharSequence hintMessage, @Nullable<method*start>android.support.annotation.Nullable<method*end> PermissionListener listener, @NonNull<method*start>android.support.annotation.NonNull<method*end> final String<method*start>java.lang.String<method*end>... permissions) {
if (listener != null) {
mListener<method*start>com.cxz.baselibs.utils.PermissionHelper.mListener<method*end> = listener;
}
mPermissionList<method*start>com.cxz.baselibs.utils.PermissionHelper.mPermissionList<method*end> = Arrays.asList<method*start>java.util.Arrays.asList<method*end>(permissions);
// 没全部权限
if (!hasPermissions<method*start>com.cxz.baselibs.utils.PermissionHelper.hasPermissions<method*end>(mContext, permissions)) {
// 需要向用户解释为什么申请这个权限
boolean shouldShowRationale = false;
for (String<method*start>java.lang.String<method*end> perm : permissions) {
shouldShowRationale = shouldShowRationale || shouldShowRequestPermissionRationale<method*start>com.cxz.baselibs.utils.PermissionHelper.shouldShowRequestPermissionRationale<method*end>(mContext, perm);
}
executePermissionsRequest<method*start>com.cxz.baselibs.utils.PermissionHelper.executePermissionsRequest<method*end>(mContext, permissions, REQUEST_PERMISSION_CODE);
} else if (mListener != null) {
// 有全部权限
mListener.doAfterGrand<method*start>com.cxz.baselibs.utils.PermissionHelper.PermissionListener.doAfterGrand<method*end>(permissions);
}
}
|
@Command(shortDescription<method*start>org.terasology.logic.console.commandSystem.annotations.Command.shortDescription<method*end> = "Gives specified permission to player", helpText<method*start>org.terasology.logic.console.commandSystem.annotations.Command.helpText<method*end> = "Gives specified permission to player", runOnServer<method*start>org.terasology.logic.console.commandSystem.annotations.Command.runOnServer<method*end> = true, requiredPermission<method*start>org.terasology.logic.console.commandSystem.annotations.Command.requiredPermission<method*end> = PermissionManager.USER_MANAGEMENT_PERMISSION<method*start>org.terasology.logic.permission.PermissionManager.USER_MANAGEMENT_PERMISSION<method*end>)
public String<method*start>java.lang.String<method*end> givePermission(@CommandParam<method*start>org.terasology.logic.console.commandSystem.annotations.CommandParam<method*end>(value<method*start>org.terasology.logic.console.commandSystem.annotations.CommandParam.value<method*end> = "player", suggester<method*start>org.terasology.logic.console.commandSystem.annotations.CommandParam.suggester<method*end> = UsernameSuggester<method*start>org.terasology.logic.console.suggesters.UsernameSuggester<method*end>.class) String<method*start>java.lang.String<method*end> player, @CommandParam<method*start>org.terasology.logic.console.commandSystem.annotations.CommandParam<method*end>("permission") String<method*start>java.lang.String<method*end> permission, @Sender<method*start>org.terasology.logic.console.commandSystem.annotations.Sender<method*end> EntityRef requester) {
boolean permissionGiven = false;
ClientComponent<method*start>org.terasology.network.ClientComponent<method*end> requesterClientComponent = requester.getComponent<method*start>org.terasology.entitySystem.entity.EntityRef.getComponent<method*end>(ClientComponent<method*start>org.terasology.network.ClientComponent<method*end>.class);
EntityRef requesterClientInfo = requesterClientComponent.clientInfo<method*start>org.terasology.network.ClientComponent.clientInfo<method*end>;
for (EntityRef client : entityManager.getEntitiesWith<method*start>org.terasology.entitySystem.entity.EntityManager.getEntitiesWith<method*end>(ClientComponent<method*start>org.terasology.network.ClientComponent<method*end>.class)) {
ClientComponent<method*start>org.terasology.network.ClientComponent<method*end> clientComponent = client.getComponent<method*start>org.terasology.entitySystem.entity.EntityRef.getComponent<method*end>(ClientComponent<method*start>org.terasology.network.ClientComponent<method*end>.class);
if (clientHasName<method*start>org.terasology.logic.permission.PermissionCommands.clientHasName<method*end>(clientComponent, player)) {
permissionManager.addPermission<method*start>org.terasology.logic.permission.PermissionManager.addPermission<method*end>(clientComponent.clientInfo<method*start>org.terasology.network.ClientComponent.clientInfo<method*end>, permission);
permissionGiven = true;
}
}
return "Permission " + permission + " added to player " + player;
} | annotation | @Command(shortDescription<method*start>org.terasology.logic.console.commandSystem.annotations.Command.shortDescription<method*end> = "Gives specified permission to player", helpText<method*start>org.terasology.logic.console.commandSystem.annotations.Command.helpText<method*end> = "Gives specified permission to player", runOnServer<method*start>org.terasology.logic.console.commandSystem.annotations.Command.runOnServer<method*end> = true, requiredPermission<method*start>org.terasology.logic.console.commandSystem.annotations.Command.requiredPermission<method*end> = PermissionManager.USER_MANAGEMENT_PERMISSION<method*start>org.terasology.logic.permission.PermissionManager.USER_MANAGEMENT_PERMISSION<method*end>)
public String<method*start>java.lang.String<method*end> givePermission(@CommandParam<method*start>org.terasology.logic.console.commandSystem.annotations.CommandParam<method*end>(value<method*start>org.terasology.logic.console.commandSystem.annotations.CommandParam.value<method*end> = "player", suggester<method*start>org.terasology.logic.console.commandSystem.annotations.CommandParam.suggester<method*end> = UsernameSuggester<method*start>org.terasology.logic.console.suggesters.UsernameSuggester<method*end>.class) String<method*start>java.lang.String<method*end> player, @CommandParam<method*start>org.terasology.logic.console.commandSystem.annotations.CommandParam<method*end>("permission") String<method*start>java.lang.String<method*end> permission, @Sender<method*start>org.terasology.logic.console.commandSystem.annotations.Sender<method*end> EntityRef requester) {
boolean permissionGiven = false;
ClientComponent<method*start>org.terasology.network.ClientComponent<method*end> requesterClientComponent = requester.getComponent<method*start>org.terasology.entitySystem.entity.EntityRef.getComponent<method*end>(ClientComponent<method*start>org.terasology.network.ClientComponent<method*end>.class);
EntityRef requesterClientInfo = requesterClientComponent.clientInfo<method*start>org.terasology.network.ClientComponent.clientInfo<method*end>;
if (!permissionManager.hasPermission<method*start>org.terasology.logic.permission.PermissionManager.hasPermission<method*end>(requesterClientInfo, permission)) {
return String.format<method*start>java.lang.String.format<method*end>("You can't give the permission %s because you don't have it yourself", permission);
}
for (EntityRef client : entityManager.getEntitiesWith<method*start>org.terasology.entitySystem.entity.EntityManager.getEntitiesWith<method*end>(ClientComponent<method*start>org.terasology.network.ClientComponent<method*end>.class)) {
ClientComponent<method*start>org.terasology.network.ClientComponent<method*end> clientComponent = client.getComponent<method*start>org.terasology.entitySystem.entity.EntityRef.getComponent<method*end>(ClientComponent<method*start>org.terasology.network.ClientComponent<method*end>.class);
if (clientHasName<method*start>org.terasology.logic.permission.PermissionCommands.clientHasName<method*end>(clientComponent, player)) {
permissionManager.addPermission<method*start>org.terasology.logic.permission.PermissionManager.addPermission<method*end>(clientComponent.clientInfo<method*start>org.terasology.network.ClientComponent.clientInfo<method*end>, permission);
permissionGiven = true;
}
}
if (permissionGiven) {
return "Permission " + permission + " added to player " + player;
} else {
return "Unable to find player " + player;
}
}
|
@TargetApi<method*start>android.annotation.TargetApi<method*end>(Build.VERSION_CODES.M<method*start>android.os.Build.VERSION_CODES.M<method*end>)
private static boolean shouldNotRequestPermission(Activity<method*start>android.app.Activity<method*end> activity, String<method*start>java.lang.String<method*end> permission, int rationale) {
if (LyricsOverlayService.isRunning<method*start>com.geecko.QuickLyric.services.LyricsOverlayService.isRunning<method*end>())
LyricsOverlayService.removeCustomFloatingView<method*start>com.geecko.QuickLyric.services.LyricsOverlayService.removeCustomFloatingView<method*end>(activity);
if (activity.shouldShowRequestPermissionRationale<method*start>android.app.Activity.shouldShowRequestPermissionRationale<method*end>(permission) && rationale != 0)
Toast.makeText<method*start>android.widget.Toast.makeText<method*end>(activity, rationale, Toast.LENGTH_LONG<method*start>android.widget.Toast.LENGTH_LONG<method*end>).show<method*start>android.widget.Toast.show<method*end>();
return false;
} | annotation | @TargetApi<method*start>android.annotation.TargetApi<method*end>(Build.VERSION_CODES.M<method*start>android.os.Build.VERSION_CODES.M<method*end>)
private static boolean shouldNotRequestPermission(Activity<method*start>android.app.Activity<method*end> activity, String<method*start>java.lang.String<method*end> permission, int rationale) {
if (hasPermission<method*start>com.geecko.QuickLyric.utils.PermissionsChecker.hasPermission<method*end>(activity, permission))
return true;
if (LyricsOverlayService.isRunning<method*start>com.geecko.QuickLyric.services.LyricsOverlayService.isRunning<method*end>())
LyricsOverlayService.removeCustomFloatingView<method*start>com.geecko.QuickLyric.services.LyricsOverlayService.removeCustomFloatingView<method*end>(activity);
if (activity.shouldShowRequestPermissionRationale<method*start>android.app.Activity.shouldShowRequestPermissionRationale<method*end>(permission) && rationale != 0)
Toast.makeText<method*start>android.widget.Toast.makeText<method*end>(activity, rationale, Toast.LENGTH_LONG<method*start>android.widget.Toast.LENGTH_LONG<method*end>).show<method*start>android.widget.Toast.show<method*end>();
return false;
}
|
@Command(aliases = { "test" }, desc = "Test for a specific permission", usage = "<permission> [player]", min = 1, max = 2)
public void test(CommandContextcom.sk89q.minecraft.util.commands.CommandContext args, CommandSenderorg.bukkit.command.CommandSender sender) throws CommandExceptioncom.sk89q.minecraft.util.commands.CommandException {
CommandSenderorg.bukkit.command.CommandSender player = CommandUtils.getCommandSenderOrSelf(args, sender, 1);
Stringjava.lang.String perm = args.getString(0);
sender.sendMessage(ChatColororg.bukkit.ChatColor.GREEN + player.getName() + " has permission " + perm);
}
} | annotation | @Command(aliases = { "test" }, desc = "Test for a specific permission", usage = "<permission> [player]", min = 1, max = 2)
public void test(CommandContext<method*start>com.sk89q.minecraft.util.commands.CommandContext<method*end> args, CommandSender<method*start>org.bukkit.command.CommandSender<method*end> sender) throws CommandException<method*start>com.sk89q.minecraft.util.commands.CommandException<method*end> {
CommandSender<method*start>org.bukkit.command.CommandSender<method*end> player = CommandUtils.getCommandSenderOrSelf(args, sender, 1);
String<method*start>java.lang.String<method*end> perm = args.getString(0);
if (player.hasPermission(perm)) {
sender.sendMessage(ChatColor<method*start>org.bukkit.ChatColor<method*end>.GREEN + player.getName() + " has permission " + perm);
} else {
sender.sendMessage(ChatColor<method*start>org.bukkit.ChatColor<method*end>.RED + player.getName() + " does NOT have permission " + perm);
}
}
|
@Override<method*start>java.lang.Override<method*end>
public int broadcast(String<method*start>java.lang.String<method*end> message, String<method*start>java.lang.String<method*end> permission) {
int count = 0;
Set<method*start>java.util.Set<method*end><Permissible<method*start>org.bukkit.permissions.Permissible<method*end>> permissibles = getPluginManager().getPermissionSubscriptions<method*start>org.bukkit.plugin.PluginManager.getPermissionSubscriptions<method*end>(permission);
for (Permissible<method*start>org.bukkit.permissions.Permissible<method*end> permissible : permissibles) {
CommandSender<method*start>org.bukkit.command.CommandSender<method*end> user = (CommandSender<method*start>org.bukkit.command.CommandSender<method*end>) permissible;
user.sendMessage<method*start>org.bukkit.command.CommandSender.sendMessage<method*end>(message);
count++;
}
}
return count;
} | annotation | @Override<method*start>java.lang.Override<method*end>
public int broadcast(String<method*start>java.lang.String<method*end> message, String<method*start>java.lang.String<method*end> permission) {
int count = 0;
Set<method*start>java.util.Set<method*end><Permissible<method*start>org.bukkit.permissions.Permissible<method*end>> permissibles = getPluginManager().getPermissionSubscriptions<method*start>org.bukkit.plugin.PluginManager.getPermissionSubscriptions<method*end>(permission);
for (Permissible<method*start>org.bukkit.permissions.Permissible<method*end> permissible : permissibles) {
if (permissible instanceof CommandSender<method*start>org.bukkit.command.CommandSender<method*end> && permissible.hasPermission<method*start>org.bukkit.permissions.Permissible.hasPermission<method*end>(permission)) {
CommandSender<method*start>org.bukkit.command.CommandSender<method*end> user = (CommandSender<method*start>org.bukkit.command.CommandSender<method*end>) permissible;
user.sendMessage<method*start>org.bukkit.command.CommandSender.sendMessage<method*end>(message);
count++;
}
}
return count;
}
|
@Override
public void broadcast(String<method*start>java.lang.String<method*end> message, String<method*start>java.lang.String<method*end> permission) {
// @TODO can't figure out how to get message channels to work ¯\_(ツ)_/¯
// MessageChannel.permission(permission).send(Sponge.getServer().getConsole(), Text.of(message));
Arrays.stream<method*start>java.util.Arrays.stream<method*end>(getOnlinePlayers()).forEach<method*start>java.util.stream.Stream.forEach<method*end>(player -> {
player.sendMessage<method*start>player.sendMessage<method*end>(message);
});
Sponge.getServer<method*start>org.spongepowered.api.Sponge.getServer<method*end>().getConsole().sendMessage(Text.of<method*start>org.spongepowered.api.text.Text.of<method*end>(message));
} | annotation | @Override
public void broadcast(String<method*start>java.lang.String<method*end> message, String<method*start>java.lang.String<method*end> permission) {
// @TODO can't figure out how to get message channels to work ¯\_(ツ)_/¯
// MessageChannel.permission(permission).send(Sponge.getServer().getConsole(), Text.of(message));
Arrays.stream<method*start>java.util.Arrays.stream<method*end>(getOnlinePlayers()).forEach<method*start>java.util.stream.Stream.forEach<method*end>(player -> {
if (player.hasPermission<method*start>player.hasPermission<method*end>(permission))
player.sendMessage<method*start>player.sendMessage<method*end>(message);
});
Sponge.getServer<method*start>org.spongepowered.api.Sponge.getServer<method*end>().getConsole().sendMessage(Text.of<method*start>org.spongepowered.api.text.Text.of<method*end>(message));
}
|
@Override
public void broadcastMessage(String<method*start>java.lang.String<method*end> message, String<method*start>java.lang.String<method*end> permission) {
// Get the set of online players with the given permission and include console.
Set<method*start>java.util.Set<method*end><CommandSender<method*start>org.bukkit.command.CommandSender<method*end>> recipients = new HashSet<method*start>java.util.HashSet<method*end><>();
for (Player<method*start>net.sf.l2j.gameserver.model.actor.instance.Player<method*end> player : this.s.getOnlinePlayers<method*start>org.bukkit.Server.getOnlinePlayers<method*end>()) {
recipients.add<method*start>java.util.Set.add<method*end>(player);
}
}
recipients.add<method*start>java.util.Set.add<method*end>(this.s.getConsoleSender<method*start>org.bukkit.Server.getConsoleSender<method*end>());
// Perform the broadcast.
this.bukkitBroadcastMessage<method*start>com.laytonsmith.abstraction.bukkit.BukkitMCServer.bukkitBroadcastMessage<method*end>(message, recipients);
} | annotation | @Override
public void broadcastMessage(String<method*start>java.lang.String<method*end> message, String<method*start>java.lang.String<method*end> permission) {
// Get the set of online players with the given permission and include console.
Set<method*start>java.util.Set<method*end><CommandSender<method*start>org.bukkit.command.CommandSender<method*end>> recipients = new HashSet<method*start>java.util.HashSet<method*end><>();
for (Player<method*start>net.sf.l2j.gameserver.model.actor.instance.Player<method*end> player : this.s.getOnlinePlayers<method*start>org.bukkit.Server.getOnlinePlayers<method*end>()) {
if (player.hasPermission<method*start>org.bukkit.entity.Player.hasPermission<method*end>(permission)) {
recipients.add<method*start>java.util.Set.add<method*end>(player);
}
}
recipients.add<method*start>java.util.Set.add<method*end>(this.s.getConsoleSender<method*start>org.bukkit.Server.getConsoleSender<method*end>());
// Perform the broadcast.
this.bukkitBroadcastMessage<method*start>com.laytonsmith.abstraction.bukkit.BukkitMCServer.bukkitBroadcastMessage<method*end>(message, recipients);
}
|
@Override
public int broadcast(String<method*start>java.lang.String<method*end> message, String<method*start>java.lang.String<method*end> permission) {
Set<method*start>java.util.Set<method*end><CommandSender<method*start>org.bukkit.command.CommandSender<method*end>> sent = new HashSet<method*start>java.util.HashSet<method*end><>();
for (Permissible<method*start>org.bukkit.permissions.Permissible<method*end> permissible : getPluginManager<method*start>net.glowstone.GlowServer.getPluginManager<method*end>().getPermissionSubscriptions<method*start>org.bukkit.plugin.PluginManager.getPermissionSubscriptions<method*end>(permission)) {
CommandSender<method*start>org.bukkit.command.CommandSender<method*end> cs = ((CommandSender<method*start>org.bukkit.command.CommandSender<method*end>) permissible);
sent.add(cs);
}
}
BroadcastMessageEvent<method*start>org.bukkit.event.server.BroadcastMessageEvent<method*end> event = EventFactory.getInstance().callEvent(new BroadcastMessageEvent<method*start>org.bukkit.event.server.BroadcastMessageEvent<method*end>(message, sent));
if (event.isCancelled()) {
return 0;
}
sent.forEach(cs -> cs.sendMessage(message));
return sent.size();
} | annotation | @Override
public int broadcast(String<method*start>java.lang.String<method*end> message, String<method*start>java.lang.String<method*end> permission) {
Set<method*start>java.util.Set<method*end><CommandSender<method*start>org.bukkit.command.CommandSender<method*end>> sent = new HashSet<method*start>java.util.HashSet<method*end><>();
for (Permissible<method*start>org.bukkit.permissions.Permissible<method*end> permissible : getPluginManager<method*start>net.glowstone.GlowServer.getPluginManager<method*end>().getPermissionSubscriptions<method*start>org.bukkit.plugin.PluginManager.getPermissionSubscriptions<method*end>(permission)) {
if (permissible instanceof CommandSender<method*start>org.bukkit.command.CommandSender<method*end> && permissible.hasPermission(permission)) {
CommandSender<method*start>org.bukkit.command.CommandSender<method*end> cs = ((CommandSender<method*start>org.bukkit.command.CommandSender<method*end>) permissible);
sent.add(cs);
}
}
BroadcastMessageEvent<method*start>org.bukkit.event.server.BroadcastMessageEvent<method*end> event = EventFactory.getInstance().callEvent(new BroadcastMessageEvent<method*start>org.bukkit.event.server.BroadcastMessageEvent<method*end>(message, sent));
if (event.isCancelled()) {
return 0;
}
sent.forEach(cs -> cs.sendMessage(message));
return sent.size();
}
|
public boolean hasBundlePermission(ProtectionDomain<method*start>java.security.ProtectionDomain<method*end> bundleProtectionDomain, Permission<method*start>java.security.Permission<method*end> permission, boolean direct) {
BundleProtectionDomain<method*start>org.apache.felix.framework.BundleProtectionDomain<method*end> pd = (BundleProtectionDomain) bundleProtectionDomain;
BundleImpl bundle = pd.getBundle<method*start>org.apache.felix.framework.BundleProtectionDomain.getBundle<method*end>();
BundleRevisionImpl module = (BundleRevisionImpl) pd.getRevision<method*start>org.apache.felix.framework.BundleProtectionDomain.getRevision<method*end>();
if (bundle.getBundleId<method*start>org.apache.felix.framework.BundleImpl.getBundleId<method*end>() == 0) {
return true;
}
Boolean<method*start>java.lang.Boolean<method*end> result = null;
if (m_pai != null) {
result = m_pai.hasPermission<method*start>org.apache.felix.framework.security.permissionadmin.PermissionAdminImpl.hasPermission<method*end>(bundle._getLocation<method*start>org.apache.felix.framework.BundleImpl._getLocation<method*end>(), pd.getBundle<method*start>org.apache.felix.framework.BundleProtectionDomain.getBundle<method*end>(), permission, m_cpai, pd, module.getContent<method*start>org.apache.felix.framework.BundleRevisionImpl.getContent<method*end>());
}
if (result != null) {
if ((m_cpai != null) && !direct) {
boolean allow = result.booleanValue<method*start>java.lang.Boolean.booleanValue<method*end>();
}
return m_cpai.handlePAHandle<method*start>org.apache.felix.framework.security.condpermadmin.ConditionalPermissionAdminImpl.handlePAHandle<method*end>(pd);
}
return result.booleanValue<method*start>java.lang.Boolean.booleanValue<method*end>();
}
if (m_cpai != null) {
try {
return m_cpai.hasPermission<method*start>org.apache.felix.framework.security.condpermadmin.ConditionalPermissionAdminImpl.hasPermission<method*end>(module, module.getContent<method*start>org.apache.felix.framework.BundleRevisionImpl.getContent<method*end>(), pd, permission, direct, m_pai);
} catch (Exception<method*start>java.lang.Exception<method*end> e) {
// TODO Auto-generated catch block
e.printStackTrace<method*start>java.lang.Exception.printStackTrace<method*end>();
}
}
return false;
} | conventional | public boolean hasBundlePermission(ProtectionDomain<method*start>java.security.ProtectionDomain<method*end> bundleProtectionDomain, Permission<method*start>java.security.Permission<method*end> permission, boolean direct) {
BundleProtectionDomain<method*start>org.apache.felix.framework.BundleProtectionDomain<method*end> pd = (BundleProtectionDomain) bundleProtectionDomain;
BundleImpl bundle = pd.getBundle<method*start>org.apache.felix.framework.BundleProtectionDomain.getBundle<method*end>();
BundleRevisionImpl module = (BundleRevisionImpl) pd.getRevision<method*start>org.apache.felix.framework.BundleProtectionDomain.getRevision<method*end>();
if (bundle.getBundleId<method*start>org.apache.felix.framework.BundleImpl.getBundleId<method*end>() == 0) {
return true;
}
// System.out.println(info.getBundleId() + " - " + permission);
// TODO: using true, false, or null seems a bit awkward. Improve this.
Boolean<method*start>java.lang.Boolean<method*end> result = null;
if (m_pai != null) {
result = m_pai.hasPermission<method*start>org.apache.felix.framework.security.permissionadmin.PermissionAdminImpl.hasPermission<method*end>(bundle._getLocation<method*start>org.apache.felix.framework.BundleImpl._getLocation<method*end>(), pd.getBundle<method*start>org.apache.felix.framework.BundleProtectionDomain.getBundle<method*end>(), permission, m_cpai, pd, module.getContent<method*start>org.apache.felix.framework.BundleRevisionImpl.getContent<method*end>());
}
if (result != null) {
if ((m_cpai != null) && !direct) {
boolean allow = result.booleanValue<method*start>java.lang.Boolean.booleanValue<method*end>();
if (!allow) {
m_cpai.clearPD<method*start>org.apache.felix.framework.security.condpermadmin.ConditionalPermissionAdminImpl.clearPD<method*end>();
return false;
}
return m_cpai.handlePAHandle<method*start>org.apache.felix.framework.security.condpermadmin.ConditionalPermissionAdminImpl.handlePAHandle<method*end>(pd);
}
return result.booleanValue<method*start>java.lang.Boolean.booleanValue<method*end>();
}
if (m_cpai != null) {
try {
return m_cpai.hasPermission<method*start>org.apache.felix.framework.security.condpermadmin.ConditionalPermissionAdminImpl.hasPermission<method*end>(module, module.getContent<method*start>org.apache.felix.framework.BundleRevisionImpl.getContent<method*end>(), pd, permission, direct, m_pai);
} catch (Exception<method*start>java.lang.Exception<method*end> e) {
// TODO Auto-generated catch block
e.printStackTrace<method*start>java.lang.Exception.printStackTrace<method*end>();
}
}
return false;
}
|
private void clearPermissions(BlankNodeOrIRI<method*start>org.apache.clerezza.commons.rdf.BlankNodeOrIRI<method*end> subject) {
ArrayList<method*start>java.util.ArrayList<method*end><Triple<method*start>org.apache.clerezza.commons.rdf.Triple<method*end>> buffer = new ArrayList<method*start>java.util.ArrayList<method*end><Triple<method*start>org.apache.clerezza.commons.rdf.Triple<method*end>>();
Lock<method*start>java.util.concurrent.locks.Lock<method*end> readLock = systemGraph.getLock<method*start>org.apache.clerezza.commons.rdf.Graph.getLock<method*end>().readLock<method*start>java.util.concurrent.locks.ReadWriteLock.readLock<method*end>();
readLock.lock<method*start>java.util.concurrent.locks.Lock.lock<method*end>();
try {
Iterator<method*start>java.util.Iterator<method*end><Triple<method*start>org.apache.clerezza.commons.rdf.Triple<method*end>> permissions = systemGraph.filter<method*start>org.apache.clerezza.commons.rdf.Graph.filter<method*end>(subject, PERMISSION.hasPermission<method*start>org.apache.clerezza.rdf.ontologies.PERMISSION.hasPermission<method*end>, null);
while (permissions.hasNext<method*start>java.util.Iterator.hasNext<method*end>()) {
Triple<method*start>org.apache.clerezza.commons.rdf.Triple<method*end> permissionTriple = permissions.next<method*start>java.util.Iterator.next<method*end>();
buffer.add<method*start>java.util.ArrayList.add<method*end>(permissionTriple);
BlankNodeOrIRI<method*start>org.apache.clerezza.commons.rdf.BlankNodeOrIRI<method*end> permissionNode = (BlankNodeOrIRI<method*start>org.apache.clerezza.commons.rdf.BlankNodeOrIRI<method*end>) permissionTriple.getObject<method*start>org.apache.clerezza.commons.rdf.Triple.getObject<method*end>();
Iterator<method*start>java.util.Iterator<method*end><Triple<method*start>org.apache.clerezza.commons.rdf.Triple<method*end>> permissionTriples = systemGraph.filter<method*start>org.apache.clerezza.commons.rdf.Graph.filter<method*end>(permissionNode, null, null);
while (permissionTriples.hasNext<method*start>java.util.Iterator.hasNext<method*end>()) {
buffer.add<method*start>java.util.ArrayList.add<method*end>(permissionTriples.next<method*start>java.util.Iterator.next<method*end>());
}
}
} finally {
readLock.unlock<method*start>java.util.concurrent.locks.Lock.unlock<method*end>();
}
systemGraph.removeAll<method*start>org.apache.clerezza.commons.rdf.Graph.removeAll<method*end>(buffer);
} | conventional | private void clearPermissions(BlankNodeOrIRI<method*start>org.apache.clerezza.commons.rdf.BlankNodeOrIRI<method*end> subject) {
ArrayList<method*start>java.util.ArrayList<method*end><Triple<method*start>org.apache.clerezza.commons.rdf.Triple<method*end>> buffer = new ArrayList<method*start>java.util.ArrayList<method*end><Triple<method*start>org.apache.clerezza.commons.rdf.Triple<method*end>>();
Lock<method*start>java.util.concurrent.locks.Lock<method*end> readLock = systemGraph.getLock<method*start>org.apache.clerezza.commons.rdf.Graph.getLock<method*end>().readLock<method*start>java.util.concurrent.locks.ReadWriteLock.readLock<method*end>();
readLock.lock<method*start>java.util.concurrent.locks.Lock.lock<method*end>();
try {
Iterator<method*start>java.util.Iterator<method*end><Triple<method*start>org.apache.clerezza.commons.rdf.Triple<method*end>> permissions = systemGraph.filter<method*start>org.apache.clerezza.commons.rdf.Graph.filter<method*end>(subject, PERMISSION.hasPermission<method*start>org.apache.clerezza.rdf.ontologies.PERMISSION.hasPermission<method*end>, null);
while (permissions.hasNext<method*start>java.util.Iterator.hasNext<method*end>()) {
Triple<method*start>org.apache.clerezza.commons.rdf.Triple<method*end> permissionTriple = permissions.next<method*start>java.util.Iterator.next<method*end>();
buffer.add<method*start>java.util.ArrayList.add<method*end>(permissionTriple);
BlankNodeOrIRI<method*start>org.apache.clerezza.commons.rdf.BlankNodeOrIRI<method*end> permissionNode = (BlankNodeOrIRI<method*start>org.apache.clerezza.commons.rdf.BlankNodeOrIRI<method*end>) permissionTriple.getObject<method*start>org.apache.clerezza.commons.rdf.Triple.getObject<method*end>();
Iterator<method*start>java.util.Iterator<method*end><Triple<method*start>org.apache.clerezza.commons.rdf.Triple<method*end>> permissionTriples = systemGraph.filter<method*start>org.apache.clerezza.commons.rdf.Graph.filter<method*end>(permissionNode, null, null);
while (permissionTriples.hasNext<method*start>java.util.Iterator.hasNext<method*end>()) {
buffer.add<method*start>java.util.ArrayList.add<method*end>(permissionTriples.next<method*start>java.util.Iterator.next<method*end>());
}
}
} finally {
readLock.unlock<method*start>java.util.concurrent.locks.Lock.unlock<method*end>();
}
systemGraph.removeAll<method*start>org.apache.clerezza.commons.rdf.Graph.removeAll<method*end>(buffer);
}
|
private List<java.util.List<String>> getPermissionEntriesOfARole(BlankNodeOrIRI role, String userName, BlankNodeOrIRI user) {
List<java.util.List<String>> result = new ArrayList<java.util.ArrayList<String>>();
Iterator<org.apache.clerezza.commons.rdf.Triple> permsForRole = systemGraph.filter(role, PERMISSION.hasPermission, null);
while (permsForRole.hasNext()) {
Iterator<org.apache.clerezza.commons.rdf.Triple> javaPermForRole = systemGraph.filter((org.apache.clerezza.commons.rdf.BlankNode) permsForRole.next().getObject(), PERMISSION.javaPermissionEntry, null);
if (javaPermForRole.hasNext()) {
org.apache.clerezza.commons.rdf.Literal permissionEntry = (org.apache.clerezza.commons.rdf.Literal) javaPermForRole.next().getObject();
String permission = permissionEntry.getLexicalForm();
result.add(permission);
}
}
return result;
} | conventional | private List<method*start>java.util.List<method*end><String<method*start>java.lang.String<method*end>> getPermissionEntriesOfARole(BlankNodeOrIRI<method*start>org.apache.clerezza.commons.rdf.BlankNodeOrIRI<method*end> role, String<method*start>java.lang.String<method*end> userName, BlankNodeOrIRI<method*start>org.apache.clerezza.commons.rdf.BlankNodeOrIRI<method*end> user) {
List<method*start>java.util.List<method*end><String<method*start>java.lang.String<method*end>> result = new ArrayList<method*start>java.util.ArrayList<method*end><String<method*start>java.lang.String<method*end>>();
Iterator<method*start>java.util.Iterator<method*end><Triple<method*start>org.apache.clerezza.commons.rdf.Triple<method*end>> permsForRole = systemGraph.filter<method*start>org.apache.clerezza.commons.rdf.Graph.filter<method*end>(role, PERMISSION.hasPermission<method*start>org.apache.clerezza.rdf.ontologies.PERMISSION.hasPermission<method*end>, null);
while (permsForRole.hasNext<method*start>java.util.Iterator.hasNext<method*end>()) {
Iterator<method*start>java.util.Iterator<method*end><Triple<method*start>org.apache.clerezza.commons.rdf.Triple<method*end>> javaPermForRole = systemGraph.filter<method*start>org.apache.clerezza.commons.rdf.Graph.filter<method*end>((BlankNode<method*start>org.apache.clerezza.commons.rdf.BlankNode<method*end>) permsForRole.next<method*start>java.util.Iterator.next<method*end>().getObject<method*start>org.apache.clerezza.commons.rdf.Triple.getObject<method*end>(), PERMISSION.javaPermissionEntry<method*start>org.apache.clerezza.rdf.ontologies.PERMISSION.javaPermissionEntry<method*end>, null);
if (javaPermForRole.hasNext<method*start>java.util.Iterator.hasNext<method*end>()) {
Literal<method*start>org.apache.clerezza.commons.rdf.Literal<method*end> permissionEntry = (Literal<method*start>org.apache.clerezza.commons.rdf.Literal<method*end>) javaPermForRole.next<method*start>java.util.Iterator.next<method*end>().getObject<method*start>org.apache.clerezza.commons.rdf.Triple.getObject<method*end>();
String<method*start>java.lang.String<method*end> permission = permissionEntry.getLexicalForm<method*start>org.apache.clerezza.commons.rdf.Literal.getLexicalForm<method*end>();
if (permission.contains<method*start>java.lang.String.contains<method*end>("{username}")) {
permission = permission.replace<method*start>java.lang.String.replace<method*end>("{username}", userName);
}
result.add<method*start>java.util.List.add<method*end>(permission);
}
}
return result;
}
|
public static boolean hasLegacy(Player<method*start>org.bukkit.entity.Player<method*end> player, String<method*start>java.lang.String<method*end> node) {
if (!Configuration.Permissions.ENABLED<method*start>de.Keyle.MyPet.api.Configuration.Permissions.ENABLED<method*end> || player.isOp<method*start>org.bukkit.entity.Player.isOp<method*end>()) {
return true;
}
for (String<method*start>java.lang.String<method*end> permission : legacy.get<method*start>com.google.common.collect.Multimap.get<method*end>(node)) {
return true;
}
}
}
return player.hasPermission<method*start>org.bukkit.entity.Player.hasPermission<method*end>(node);
}
return false;
}
| conventional | public static boolean hasLegacy(Player<method*start>org.bukkit.entity.Player<method*end> player, String<method*start>java.lang.String<method*end> node) {
if (player != null) {
if (!Configuration.Permissions.ENABLED<method*start>de.Keyle.MyPet.api.Configuration.Permissions.ENABLED<method*end> || player.isOp<method*start>org.bukkit.entity.Player.isOp<method*end>()) {
return true;
}
if (Configuration.Permissions.LEGACY<method*start>de.Keyle.MyPet.api.Configuration.Permissions.LEGACY<method*end> && legacy.containsKey<method*start>com.google.common.collect.Multimap.containsKey<method*end>(node)) {
for (String<method*start>java.lang.String<method*end> permission : legacy.get<method*start>com.google.common.collect.Multimap.get<method*end>(node)) {
if (player.hasPermission<method*start>org.bukkit.entity.Player.hasPermission<method*end>(permission)) {
return true;
}
}
}
return player.hasPermission<method*start>org.bukkit.entity.Player.hasPermission<method*end>(node);
}
return false;
}
|
private boolean checkEntityTypePermission(String<method*start>java.lang.String<method*end> entityTypeId, Action<method*start>org.molgenis.data.security.owned.AbstractRowLevelSecurityRepositoryDecorator.Action<method*end> action) {
EntityTypePermission<method*start>org.molgenis.data.security.EntityTypePermission<method*end> permission = getPermissionForAction<method*start>org.molgenis.data.security.meta.EntityTypeRepositorySecurityDecorator.getPermissionForAction<method*end>(action);
boolean hasPermission = userPermissionEvaluator.hasPermission<method*start>org.molgenis.security.core.UserPermissionEvaluator.hasPermission<method*end>(new EntityTypeIdentity<method*start>org.molgenis.data.security.EntityTypeIdentity<method*end>(entityTypeId), permission);
boolean isSystem = systemEntityTypeRegistry.hasSystemEntityType<method*start>org.molgenis.data.meta.system.SystemEntityTypeRegistry.hasSystemEntityType<method*end>(entityTypeId);
if (isSystem && !currentUserIsSystem<method*start>org.molgenis.security.core.utils.SecurityUtils.currentUserIsSystem<method*end>()) {
throw new SystemMetadataModificationException<method*start>org.molgenis.data.security.exception.SystemMetadataModificationException<method*end>();
}
}
return hasPermission;
}
| conventional | private boolean checkEntityTypePermission(String<method*start>java.lang.String<method*end> entityTypeId, Action<method*start>org.molgenis.data.security.owned.AbstractRowLevelSecurityRepositoryDecorator.Action<method*end> action) {
EntityTypePermission<method*start>org.molgenis.data.security.EntityTypePermission<method*end> permission = getPermissionForAction<method*start>org.molgenis.data.security.meta.EntityTypeRepositorySecurityDecorator.getPermissionForAction<method*end>(action);
boolean hasPermission = userPermissionEvaluator.hasPermission<method*start>org.molgenis.security.core.UserPermissionEvaluator.hasPermission<method*end>(new EntityTypeIdentity<method*start>org.molgenis.data.security.EntityTypeIdentity<method*end>(entityTypeId), permission);
if (hasPermission && action != Action.COUNT<method*start>org.molgenis.data.security.owned.AbstractRowLevelSecurityRepositoryDecorator.Action.COUNT<method*end> && action != Action.READ<method*start>org.molgenis.data.security.owned.AbstractRowLevelSecurityRepositoryDecorator.Action.READ<method*end>) {
boolean isSystem = systemEntityTypeRegistry.hasSystemEntityType<method*start>org.molgenis.data.meta.system.SystemEntityTypeRegistry.hasSystemEntityType<method*end>(entityTypeId);
if (isSystem && !currentUserIsSystem<method*start>org.molgenis.security.core.utils.SecurityUtils.currentUserIsSystem<method*end>()) {
throw new SystemMetadataModificationException<method*start>org.molgenis.data.security.exception.SystemMetadataModificationException<method*end>();
}
}
return hasPermission;
}
|
default boolean tryExtendedGroups(IPermissionGroup permissionGroup, Permission permission) {
switch(permissionGroup.hasPermission(permission)) {
case ALLOWED:
return true;
case FORBIDDEN:
return false;
default:
for (IPermissionGroup extended : getExtendedGroups(permissionGroup)) {
if (tryExtendedGroups(extended, permission)) {
return true;
}
}
break;
}
return false;
} | conventional | default boolean tryExtendedGroups(IPermissionGroup<method*start>de.dytanic.cloudnet.driver.permission.IPermissionGroup<method*end> permissionGroup, Permission<method*start>de.dytanic.cloudnet.driver.permission.Permission<method*end> permission) {
if (permissionGroup == null) {
return false;
}
switch(permissionGroup.hasPermission<method*start>de.dytanic.cloudnet.driver.permission.IPermissionGroup.hasPermission<method*end>(permission)) {
case ALLOWED:
return true;
case FORBIDDEN:
return false;
default:
for (IPermissionGroup<method*start>de.dytanic.cloudnet.driver.permission.IPermissionGroup<method*end> extended : getExtendedGroups(permissionGroup)) {
if (tryExtendedGroups(extended, permission)) {
return true;
}
}
break;
}
return false;
}
|
public boolean check(@Nonnull MiddlewareStack stack) {
String<method*start>java.lang.String<method*end>[] permissions = Arrays.copyOfRange<method*start>java.util.Arrays.copyOfRange<method*end>(args, 1, args.length<method*start>java.lang.String[].length<method*end>);
for (String<method*start>java.lang.String<method*end> permissionNode : permissions) {
Permissions<method*start>com.avairebot.permissions.Permissions<method*end> permission = Permissions.fromNode<method*start>com.avairebot.permissions.Permissions.fromNode<method*end>(permissionNode);
log.warn<method*start>org.slf4j.Logger.warn<method*end>(String.format<method*start>java.lang.String.format<method*end>("Invalid permission node given for the \"%s\" command: %s", stack.getCommand<method*start>com.avairebot.middleware.MiddlewareStack.getCommand<method*end>().getName<method*start>com.avairebot.contracts.commands.Command.getName<method*end>(), permissionNode));
return false;
}
missingUserPermissions.add<method*start>java.util.List.add<method*end>(permission);
}
if (!message.getGuild<method*start>net.dv8tion.jda.core.entities.Message.getGuild<method*end>().getSelfMember().hasPermission(permission.getPermission<method*start>com.avairebot.permissions.Permissions.getPermission<method*end>())) {
missingBotPermissions.add<method*start>java.util.List.add<method*end>(permission);
continue;
}
if (!message.getGuild<method*start>net.dv8tion.jda.core.entities.Message.getGuild<method*end>().getSelfMember().hasPermission(message.getTextChannel<method*start>net.dv8tion.jda.core.entities.Message.getTextChannel<method*end>(), permission.getPermission<method*start>com.avairebot.permissions.Permissions.getPermission<method*end>())) {
missingBotPermissions.add<method*start>java.util.List.add<method*end>(permission);
}
}
}
botHasAtleastOne = missingBotPermissions.size<method*start>java.util.List.size<method*end>() < permissions.length<method*start>java.lang.String[].length<method*end>;
if (!userHasAtleastOne) {
userHasAtleastOne = missingUserPermissions.size<method*start>java.util.List.size<method*end>() < permissions.length<method*start>java.lang.String[].length<method*end>;
}
return true;
} | annotation | public boolean check(@Nonnull MiddlewareStack stack) {
String<method*start>java.lang.String<method*end>[] permissions = Arrays.copyOfRange<method*start>java.util.Arrays.copyOfRange<method*end>(args, 1, args.length<method*start>java.lang.String[].length<method*end>);
for (String<method*start>java.lang.String<method*end> permissionNode : permissions) {
Permissions<method*start>com.avairebot.permissions.Permissions<method*end> permission = Permissions.fromNode<method*start>com.avairebot.permissions.Permissions.fromNode<method*end>(permissionNode);
if (permission == null) {
log.warn<method*start>org.slf4j.Logger.warn<method*end>(String.format<method*start>java.lang.String.format<method*end>("Invalid permission node given for the \"%s\" command: %s", stack.getCommand<method*start>com.avairebot.middleware.MiddlewareStack.getCommand<method*end>().getName<method*start>com.avairebot.contracts.commands.Command.getName<method*end>(), permissionNode));
return false;
}
if (!isUserAdmin && type.isCheckUser<method*start>com.avairebot.middleware.permission.PermissionType.isCheckUser<method*end>() && !message.getMember<method*start>net.dv8tion.jda.core.entities.Message.getMember<method*end>().hasPermission(permission.getPermission<method*start>com.avairebot.permissions.Permissions.getPermission<method*end>())) {
missingUserPermissions.add<method*start>java.util.List.add<method*end>(permission);
}
if (type.isCheckBot<method*start>com.avairebot.middleware.permission.PermissionType.isCheckBot<method*end>()) {
if (!message.getGuild<method*start>net.dv8tion.jda.core.entities.Message.getGuild<method*end>().getSelfMember().hasPermission(permission.getPermission<method*start>com.avairebot.permissions.Permissions.getPermission<method*end>())) {
missingBotPermissions.add<method*start>java.util.List.add<method*end>(permission);
continue;
}
if (!message.getGuild<method*start>net.dv8tion.jda.core.entities.Message.getGuild<method*end>().getSelfMember().hasPermission(message.getTextChannel<method*start>net.dv8tion.jda.core.entities.Message.getTextChannel<method*end>(), permission.getPermission<method*start>com.avairebot.permissions.Permissions.getPermission<method*end>())) {
missingBotPermissions.add<method*start>java.util.List.add<method*end>(permission);
}
}
}
botHasAtleastOne = missingBotPermissions.size<method*start>java.util.List.size<method*end>() < permissions.length<method*start>java.lang.String[].length<method*end>;
if (!userHasAtleastOne) {
userHasAtleastOne = missingUserPermissions.size<method*start>java.util.List.size<method*end>() < permissions.length<method*start>java.lang.String[].length<method*end>;
}
return true;
}
|
@Override<method*start>java.lang.Override<method*end>
public boolean isModelAuthorized(ISecureModel<method*start>org.wicketstuff.security.models.ISecureModel<method*end><?> model, Component<method*start>org.apache.wicket.Component<method*end> component, WaspAction<method*start>org.wicketstuff.security.actions.WaspAction<method*end> action) {
DataPermission<method*start>org.wicketstuff.security.hive.authorization.permissions.DataPermission<method*end> permission;
permission = new DataPermission<method*start>org.wicketstuff.security.hive.authorization.permissions.DataPermission<method*end>(component, (SwarmModel<method*start>org.wicketstuff.security.swarm.models.SwarmModel<method*end><?>) model, (SwarmAction<method*start>org.wicketstuff.security.swarm.actions.SwarmAction<method*end>) action);
else
permission = new DataPermission<method*start>org.wicketstuff.security.hive.authorization.permissions.DataPermission<method*end>(String.valueOf<method*start>java.lang.String.valueOf<method*end>(model), action);
return true;
IAuthorizationMessageSource<method*start>org.wicketstuff.security.log.IAuthorizationMessageSource<method*end> message = getMessageSource<method*start>org.wicketstuff.security.strategies.WaspAuthorizationStrategy.getMessageSource<method*end>();
if (message != null) {
message.setComponent<method*start>org.wicketstuff.security.log.IAuthorizationMessageSource.setComponent<method*end>(component);
logMessage<method*start>org.wicketstuff.security.strategies.WaspAuthorizationStrategy.logMessage<method*end>(message);
}
return false;
}
| annotation | @Override<method*start>java.lang.Override<method*end>
public boolean isModelAuthorized(ISecureModel<method*start>org.wicketstuff.security.models.ISecureModel<method*end><?> model, Component<method*start>org.apache.wicket.Component<method*end> component, WaspAction<method*start>org.wicketstuff.security.actions.WaspAction<method*end> action) {
DataPermission<method*start>org.wicketstuff.security.hive.authorization.permissions.DataPermission<method*end> permission;
if (model instanceof SwarmModel<method*start>org.wicketstuff.security.swarm.models.SwarmModel<method*end><?>)
permission = new DataPermission<method*start>org.wicketstuff.security.hive.authorization.permissions.DataPermission<method*end>(component, (SwarmModel<method*start>org.wicketstuff.security.swarm.models.SwarmModel<method*end><?>) model, (SwarmAction<method*start>org.wicketstuff.security.swarm.actions.SwarmAction<method*end>) action);
else
permission = new DataPermission<method*start>org.wicketstuff.security.hive.authorization.permissions.DataPermission<method*end>(String.valueOf<method*start>java.lang.String.valueOf<method*end>(model), action);
if (hasPermission(permission))
return true;
IAuthorizationMessageSource<method*start>org.wicketstuff.security.log.IAuthorizationMessageSource<method*end> message = getMessageSource<method*start>org.wicketstuff.security.strategies.WaspAuthorizationStrategy.getMessageSource<method*end>();
if (message != null) {
message.setComponent<method*start>org.wicketstuff.security.log.IAuthorizationMessageSource.setComponent<method*end>(component);
logMessage<method*start>org.wicketstuff.security.strategies.WaspAuthorizationStrategy.logMessage<method*end>(message);
}
return false;
}
|
@GET
@Path("parameters")
public Map<String, String> getParameters() throws GuacamoleException {
SystemPermissionSet systemPermissions = effective.getSystemPermissions();
ObjectPermissionSet sharingProfilePermissions = effective.getSharingProfilePermissions();
String identifier = sharingProfile.getIdentifier();
throw new GuacamoleSecurityException("Permission to read sharing profile parameters denied.");
return sharingProfile.getParameters();
} | annotation | @GET<method*start>javax.ws.rs.GET<method*end>
@Path<method*start>javax.ws.rs.Path<method*end>("parameters")
public Map<method*start>java.util.Map<method*end><String<method*start>java.lang.String<method*end>, String<method*start>java.lang.String<method*end>> getParameters() throws GuacamoleException<method*start>org.apache.guacamole.GuacamoleException<method*end> {
// Pull effective permissions
Permissions<method*start>org.apache.guacamole.net.auth.Permissions<method*end> effective = userContext.self<method*start>org.apache.guacamole.net.auth.UserContext.self<method*end>().getEffectivePermissions<method*start>org.apache.guacamole.net.auth.User.getEffectivePermissions<method*end>();
// Retrieve permission sets
SystemPermissionSet<method*start>org.apache.guacamole.auth.jdbc.permission.SystemPermissionSet<method*end> systemPermissions = effective.getSystemPermissions<method*start>org.apache.guacamole.net.auth.Permissions.getSystemPermissions<method*end>();
ObjectPermissionSet<method*start>org.apache.guacamole.net.auth.permission.ObjectPermissionSet<method*end> sharingProfilePermissions = effective.getSharingProfilePermissions<method*start>org.apache.guacamole.net.auth.Permissions.getSharingProfilePermissions<method*end>();
// Deny access if adminstrative or update permission is missing
String<method*start>java.lang.String<method*end> identifier = sharingProfile.getIdentifier<method*start>org.apache.guacamole.net.auth.SharingProfile.getIdentifier<method*end>();
if (!systemPermissions.hasPermission<method*start>org.apache.guacamole.net.auth.permission.SystemPermissionSet.hasPermission<method*end>(SystemPermission.Type.ADMINISTER<method*start>org.apache.guacamole.net.auth.permission.SystemPermission.Type.ADMINISTER<method*end>) && !sharingProfilePermissions.hasPermission<method*start>org.apache.guacamole.net.auth.permission.ObjectPermissionSet.hasPermission<method*end>(ObjectPermission.Type.UPDATE<method*start>org.apache.guacamole.net.auth.permission.ObjectPermission.Type.UPDATE<method*end>, identifier))
throw new GuacamoleSecurityException<method*start>org.apache.guacamole.GuacamoleSecurityException<method*end>("Permission to read sharing profile parameters denied.");
// Return parameter map
return sharingProfile.getParameters<method*start>org.apache.guacamole.net.auth.SharingProfile.getParameters<method*end>();
}
|
@GET
@Path("parameters")
public Map<String, String> getConnectionParameters() throws GuacamoleException {
// Pull effective permissions
Permissions effective = userContext.self().getEffectivePermissions();
// Retrieve permission sets
SystemPermissionSet systemPermissions = effective.getSystemPermissions();
ObjectPermissionSet connectionPermissions = effective.getConnectionPermissions();
// Deny access if adminstrative or update permission is missing
String identifier = connection.getIdentifier();
throw new GuacamoleSecurityException("Permission to read connection parameters denied.");
// Retrieve connection configuration
GuacamoleConfiguration config = connection.getConfiguration();
// Return parameter map
return config.getParameters();
} | annotation | @GET<method*start>javax.ws.rs.GET<method*end>
@Path<method*start>javax.ws.rs.Path<method*end>("parameters")
public Map<method*start>java.util.Map<method*end><String<method*start>java.lang.String<method*end>, String<method*start>java.lang.String<method*end>> getConnectionParameters() throws GuacamoleException<method*start>org.apache.guacamole.GuacamoleException<method*end> {
// Pull effective permissions
Permissions<method*start>org.apache.guacamole.net.auth.Permissions<method*end> effective = userContext.self<method*start>org.apache.guacamole.net.auth.UserContext.self<method*end>().getEffectivePermissions<method*start>org.apache.guacamole.net.auth.User.getEffectivePermissions<method*end>();
// Retrieve permission sets
SystemPermissionSet<method*start>org.apache.guacamole.auth.jdbc.permission.SystemPermissionSet<method*end> systemPermissions = effective.getSystemPermissions<method*start>org.apache.guacamole.net.auth.Permissions.getSystemPermissions<method*end>();
ObjectPermissionSet<method*start>org.apache.guacamole.net.auth.permission.ObjectPermissionSet<method*end> connectionPermissions = effective.getConnectionPermissions<method*start>org.apache.guacamole.net.auth.Permissions.getConnectionPermissions<method*end>();
// Deny access if adminstrative or update permission is missing
String<method*start>java.lang.String<method*end> identifier = connection.getIdentifier<method*start>org.apache.guacamole.net.auth.Connection.getIdentifier<method*end>();
if (!systemPermissions.hasPermission<method*start>org.apache.guacamole.net.auth.permission.SystemPermissionSet.hasPermission<method*end>(SystemPermission.Type.ADMINISTER<method*start>org.apache.guacamole.net.auth.permission.SystemPermission.Type.ADMINISTER<method*end>) && !connectionPermissions.hasPermission<method*start>org.apache.guacamole.net.auth.permission.ObjectPermissionSet.hasPermission<method*end>(ObjectPermission.Type.UPDATE<method*start>org.apache.guacamole.net.auth.permission.ObjectPermission.Type.UPDATE<method*end>, identifier))
throw new GuacamoleSecurityException<method*start>org.apache.guacamole.GuacamoleSecurityException<method*end>("Permission to read connection parameters denied.");
// Retrieve connection configuration
GuacamoleConfiguration<method*start>org.apache.guacamole.protocol.GuacamoleConfiguration<method*end> config = connection.getConfiguration<method*start>org.apache.guacamole.net.auth.Connection.getConfiguration<method*end>();
// Return parameter map
return config.getParameters<method*start>org.apache.guacamole.protocol.GuacamoleConfiguration.getParameters<method*end>();
}
|
protected boolean hasEditPermission(PropertyFileDescriptor descriptor) {
Session session = getSession();
CDOAuthenticatedSession authSession = (CDOAuthenticatedSession) session;
User user = authSession.getUser();
Project project = descriptor.getProjectLocale().getParent().getParent();
String permission = CommonPermissions.constructPermissionName(CommonPermissions.PROJECT, project.getName(), CommonPermissions.ACTION_EDIT);
return user.hasPermission(permission);
return false;
} | conventional | protected boolean hasEditPermission(PropertyFileDescriptor<method*start>org.jabylon.properties.PropertyFileDescriptor<method*end> descriptor) {
Session<method*start>org.apache.wicket.Session<method*end> session = getSession<method*start>org.apache.wicket.markup.html.panel.GenericPanel.getSession<method*end>();
if (session instanceof CDOAuthenticatedSession<method*start>org.jabylon.rest.ui.security.CDOAuthenticatedSession<method*end>) {
CDOAuthenticatedSession<method*start>org.jabylon.rest.ui.security.CDOAuthenticatedSession<method*end> authSession = (CDOAuthenticatedSession<method*start>org.jabylon.rest.ui.security.CDOAuthenticatedSession<method*end>) session;
User<method*start>org.jabylon.users.User<method*end> user = authSession.getUser<method*start>org.jabylon.rest.ui.security.CDOAuthenticatedSession.getUser<method*end>();
if (user != null) {
Project<method*start>org.jabylon.properties.Project<method*end> project = descriptor.getProjectLocale<method*start>org.jabylon.properties.PropertyFileDescriptor.getProjectLocale<method*end>().getParent().getParent();
String<method*start>java.lang.String<method*end> permission = CommonPermissions.constructPermissionName<method*start>org.jabylon.security.CommonPermissions.constructPermissionName<method*end>(CommonPermissions.PROJECT<method*start>org.jabylon.security.CommonPermissions.PROJECT<method*end>, project.getName<method*start>org.jabylon.properties.Project.getName<method*end>(), CommonPermissions.ACTION_EDIT<method*start>org.jabylon.security.CommonPermissions.ACTION_EDIT<method*end>);
return user.hasPermission<method*start>org.jabylon.users.User.hasPermission<method*end>(permission);
}
}
return false;
}
|
@SuppressWarnings("unchecked")
@Override
public boolean testPermissionSilent(CommandSender<method*start>org.bukkit.command.CommandSender<method*end> sender) {
if (registeredWith instanceof CommandsManager<method*start>com.sk89q.minecraft.util.commands.CommandsManager<method*end><?>) {
try {
for (String<method*start>java.lang.String<method*end> permission : permissions) {
return false;
} catch (Throwable<method*start>java.lang.Throwable<method*end> ignore) {
}
}
return super.testPermissionSilent(sender);
} | annotation | @SuppressWarnings("unchecked")
@Override
public boolean testPermissionSilent(CommandSender<method*start>org.bukkit.command.CommandSender<method*end> sender) {
if (permissions<method*start>com.sk89q.bukkit.util.DynamicPluginCommand.permissions<method*end> == null || permissions<method*start>com.sk89q.bukkit.util.DynamicPluginCommand.permissions<method*end>.length == 0) {
return true;
}
if (registeredWith instanceof CommandsManager<method*start>com.sk89q.minecraft.util.commands.CommandsManager<method*end><?>) {
try {
for (String<method*start>java.lang.String<method*end> permission : permissions) {
if (((CommandsManager<method*start>com.sk89q.minecraft.util.commands.CommandsManager<method*end><CommandSender<method*start>org.bukkit.command.CommandSender<method*end>>) registeredWith).hasPermission(sender, permission)) {
return true;
}
}
return false;
} catch (Throwable<method*start>java.lang.Throwable<method*end> ignore) {
}
}
return super.testPermissionSilent(sender);
}
|
private void checkAccess(Operation systems.dmx.core.service.accesscontrol.Operation operation, long objectId) {
if (!inRequestScope()) {
logger.fine("### Object " + objectId + " is accessed by \"System\" -- " + operation + " permission is granted");
return;
}
//
String username = getUsername();
throw new AccessControlException(userInfo(username) + " has no " + operation + " permission for object " + objectId);
} | conventional | private void checkAccess(Operation<method*start>systems.dmx.core.service.accesscontrol.Operation<method*end> operation, long objectId) {
if (!inRequestScope<method*start>systems.dmx.accesscontrol.AccessControlPlugin.inRequestScope<method*end>()) {
logger.fine<method*start>java.util.logging.Logger.fine<method*end>("### Object " + objectId + " is accessed by \"System\" -- " + operation + " permission is granted");
return;
}
//
String<method*start>java.lang.String<method*end> username = getUsername();
if (!hasPermission<method*start>systems.dmx.accesscontrol.AccessControlPlugin.hasPermission<method*end>(username, operation, objectId)) {
throw new AccessControlException<method*start>systems.dmx.core.service.accesscontrol.AccessControlException<method*end>(userInfo<method*start>systems.dmx.accesscontrol.AccessControlPlugin.userInfo<method*end>(username) + " has no " + operation + " permission for object " + objectId);
}
}
|
public Map<java.util.Map<String, ? extends Object>, Object> evalPermission(DispatchContext dctx, Map<String, ? extends Object> context) {
GenericValue userLogin = (GenericValue) context.get("userLogin");
Locale locale = (Locale) context.get("locale");
Security security = dctx.getSecurity();
Debug.logInfo("Secure service requested with no userLogin object", module);
return ServiceUtil.returnError(UtilProperties.getMessage(resource, "ServicePermissionErrorUserLoginMissing", locale));
boolean hasPermission = false;
if (Debug.verboseOn())
Debug.logVerbose(" Permission : Analyse " + this.toString(), module);
switch(permissionType) {
case PERMISSION:
hasPermission = evalSimplePermission(security, userLogin);
break;
case ENTITY_PERMISSION:
hasPermission = evalEntityPermission(security, userLogin);
break;
case PERMISSION_SERVICE:
return evalPermissionService(serviceModel, dctx, context);
default:
Debug.logWarning("Invalid permission type [" + permissionType + "] for permission named : " + nameOrRole + " on service : " + serviceModel.name, module);
return ServiceUtil.returnError(UtilProperties.getMessage(resource, "ServicePermissionErrorInvalidPermissionType", locale));
}
return ServiceUtil.returnError(UtilProperties.getMessage(resource, "ServicePermissionErrorRefused", locale));
return ServiceUtil.returnSuccess();
} | conventional | public Map<method*start>java.util.Map<method*end><String<method*start>java.lang.String<method*end>, Object<method*start>java.lang.Object<method*end>> evalPermission(DispatchContext<method*start>org.apache.ofbiz.service.DispatchContext<method*end> dctx, Map<method*start>java.util.Map<method*end><String<method*start>java.lang.String<method*end>, ? extends Object<method*start>java.lang.Object<method*end>> context) {
GenericValue<method*start>org.apache.ofbiz.entity.GenericValue<method*end> userLogin = (GenericValue) context.get<method*start>java.util.Map.get<method*end>("userLogin");
Locale<method*start>java.util.Locale<method*end> locale = (Locale<method*start>java.util.Locale<method*end>) context.get<method*start>java.util.Map.get<method*end>("locale");
Security security = dctx.getSecurity<method*start>org.apache.ofbiz.service.DispatchContext.getSecurity<method*end>();
if (userLogin == null) {
Debug.logInfo<method*start>org.apache.ofbiz.base.util.Debug.logInfo<method*end>("Secure service requested with no userLogin object", module);
return ServiceUtil.returnError<method*start>org.apache.ofbiz.service.ServiceUtil.returnError<method*end>(UtilProperties.getMessage<method*start>org.apache.ofbiz.base.util.UtilProperties.getMessage<method*end>(resource, "ServicePermissionErrorUserLoginMissing", locale));
}
boolean hasPermission = false;
if (Debug.verboseOn<method*start>org.apache.ofbiz.base.util.Debug.verboseOn<method*end>())
Debug.logVerbose<method*start>org.apache.ofbiz.base.util.Debug.logVerbose<method*end>(" Permission : Analyse " + this.toString<method*start>org.apache.ofbiz.service.ModelPermission.toString<method*end>(), module);
switch(permissionType) {
case PERMISSION:
hasPermission = evalSimplePermission<method*start>org.apache.ofbiz.service.ModelPermission.evalSimplePermission<method*end>(security, userLogin);
break;
case ENTITY_PERMISSION:
hasPermission = evalEntityPermission<method*start>org.apache.ofbiz.service.ModelPermission.evalEntityPermission<method*end>(security, userLogin);
break;
case PERMISSION_SERVICE:
return evalPermissionService<method*start>org.apache.ofbiz.service.ModelPermission.evalPermissionService<method*end>(serviceModel, dctx, context);
default:
Debug.logWarning<method*start>org.apache.ofbiz.base.util.Debug.logWarning<method*end>("Invalid permission type [" + permissionType + "] for permission named : " + nameOrRole + " on service : " + serviceModel.name<method*start>org.apache.ofbiz.service.ModelService.name<method*end>, module);
return ServiceUtil.returnError<method*start>org.apache.ofbiz.service.ServiceUtil.returnError<method*end>(UtilProperties.getMessage<method*start>org.apache.ofbiz.base.util.UtilProperties.getMessage<method*end>(resource, "ServicePermissionErrorInvalidPermissionType", locale));
}
if (!hasPermission) {
return ServiceUtil.returnError<method*start>org.apache.ofbiz.service.ServiceUtil.returnError<method*end>(UtilProperties.getMessage<method*start>org.apache.ofbiz.base.util.UtilProperties.getMessage<method*end>(resource, "ServicePermissionErrorRefused", locale));
}
return ServiceUtil.returnSuccess<method*start>org.apache.ofbiz.service.ServiceUtil.returnSuccess<method*end>();
}
|
public int sendAdminNotifyMessageSubscriptions(final String message) {
final Set<Permissible> permissibles = Bukkit.getPluginManager().getPermissionSubscriptions(lcPerm);
final Set<String> done = new HashSet<String>(permissibles.size());
for (final Permissible permissible : permissibles) {
final CommandSender sender = (CommandSender) permissible;
if (sender instanceof Player) {
final IPlayerData data = DataManager.getPlayerData(player);
if (data.getNotifyOff() || !data.hasPermission(Permissions.NOTIFY, player)) {
continue;
}
} else if (!sender.hasPermission(bukkitPerm)) {
continue;
}
sender.sendMessage(message);
done.add(sender.getName());
}
}
return done.size();
} | conventional | public int sendAdminNotifyMessageSubscriptions(final String<method*start>java.lang.String<method*end> message) {
// TODO: Fetch from PlayerData - alt: update subscriptions on a regular basis - not every call!
final String<method*start>java.lang.String<method*end> lcPerm = Permissions.NOTIFY.getLowerCaseStringRepresentation();
final Permission<method*start>org.bukkit.permissions.Permission<method*end> bukkitPerm = Permissions.NOTIFY.getBukkitPermission();
final Set<method*start>java.util.Set<method*end><Permissible<method*start>org.bukkit.permissions.Permissible<method*end>> permissibles = Bukkit<method*start>org.bukkit.Bukkit<method*end>.getPluginManager().getPermissionSubscriptions(lcPerm);
final Set<method*start>java.util.Set<method*end><String<method*start>java.lang.String<method*end>> done = new HashSet<method*start>java.util.HashSet<method*end><String<method*start>java.lang.String<method*end>>(permissibles.size());
for (final Permissible<method*start>org.bukkit.permissions.Permissible<method*end> permissible : permissibles) {
if (permissible instanceof CommandSender<method*start>org.bukkit.command.CommandSender<method*end>) {
final CommandSender<method*start>org.bukkit.command.CommandSender<method*end> sender = (CommandSender<method*start>org.bukkit.command.CommandSender<method*end>) permissible;
if (sender instanceof Player<method*start>org.bukkit.entity.Player<method*end>) {
// Use the permission caching feature.
final Player<method*start>org.bukkit.entity.Player<method*end> player = (Player<method*start>org.bukkit.entity.Player<method*end>) sender;
final IPlayerData data = DataManager.getPlayerData(player);
if (data.getNotifyOff() || !data.hasPermission(Permissions.NOTIFY, player)) {
continue;
}
} else if (!sender.hasPermission(bukkitPerm)) {
// TODO: Add permission cache for non-player-things?
continue;
}
// Finally send.
sender.sendMessage(message);
done.add(sender.getName());
}
}
return done.size();
}
|
public Object<method*start>java.lang.Object<method*end> hasPermission(ProceedingJoinPoint<method*start>org.aspectj.lang.ProceedingJoinPoint<method*end> proceedingJoinPoint) throws Throwable<method*start>java.lang.Throwable<method*end> {
MethodSignature<method*start>org.aspectj.lang.reflect.MethodSignature<method*end> methodSignature = (MethodSignature<method*start>org.aspectj.lang.reflect.MethodSignature<method*end>) proceedingJoinPoint.getSignature<method*start>org.aspectj.lang.ProceedingJoinPoint.getSignature<method*end>();
DisableHasPermission<method*start>com.sequenceiq.cloudbreak.workspace.repository.DisableHasPermission<method*end> disabled = getAnnotation<method*start>com.sequenceiq.cloudbreak.workspace.HasPermissionService.getAnnotation<method*end>(methodSignature, DisableHasPermission<method*start>com.sequenceiq.cloudbreak.workspace.repository.DisableHasPermission<method*end>.class);
if (disabled != null) {
return proceedingJoinPoint.proceed<method*start>org.aspectj.lang.ProceedingJoinPoint.proceed<method*end>();
}
HasPermission<method*start>com.sequenceiq.cloudbreak.workspace.repository.HasPermission<method*end> annotation = getAnnotation<method*start>com.sequenceiq.cloudbreak.workspace.HasPermissionService.getAnnotation<method*end>(methodSignature, HasPermission<method*start>com.sequenceiq.cloudbreak.workspace.repository.HasPermission<method*end>.class);
validate<method*start>com.sequenceiq.cloudbreak.workspace.HasPermissionService.validate<method*end>(proceedingJoinPoint, annotation);
Object<method*start>java.lang.Object<method*end> target = findTargetByAnnotation<method*start>com.sequenceiq.cloudbreak.workspace.HasPermissionService.findTargetByAnnotation<method*end>(proceedingJoinPoint, annotation);
LOGGER.debug<method*start>org.slf4j.Logger.debug<method*end>("PRE-{} permission for: {}", annotation.permission<method*start>com.sequenceiq.cloudbreak.workspace.repository.HasPermission.permission<method*end>(), target);
authorizationService.hasPermission<method*start>com.sequenceiq.cloudbreak.workspace.AuthorizationService.hasPermission<method*end>(target, annotation.permission<method*start>com.sequenceiq.cloudbreak.workspace.repository.HasPermission.permission<method*end>().name<method*start>com.sequenceiq.cloudbreak.workspace.repository.PermissionType.name<method*end>());
}
Object<method*start>java.lang.Object<method*end> proceed = proceedingJoinPoint.proceed<method*start>org.aspectj.lang.ProceedingJoinPoint.proceed<method*end>();
if (proceed == null) {
logBecauseOfReturnNull<method*start>com.sequenceiq.cloudbreak.workspace.HasPermissionService.logBecauseOfReturnNull<method*end>(methodSignature);
}
if (annotation.condition<method*start>com.sequenceiq.cloudbreak.workspace.repository.HasPermission.condition<method*end>() == ConditionType.POST<method*start>com.sequenceiq.cloudbreak.workspace.repository.ConditionType.POST<method*end>) {
LOGGER.debug<method*start>org.slf4j.Logger.debug<method*end>("POST-{} permission for: {}", annotation.permission<method*start>com.sequenceiq.cloudbreak.workspace.repository.HasPermission.permission<method*end>(), proceed);
authorizationService.hasPermission<method*start>com.sequenceiq.cloudbreak.workspace.AuthorizationService.hasPermission<method*end>(proceed, annotation.permission<method*start>com.sequenceiq.cloudbreak.workspace.repository.HasPermission.permission<method*end>().name<method*start>com.sequenceiq.cloudbreak.workspace.repository.PermissionType.name<method*end>());
}
return proceed;
} | conventional | public Object<method*start>java.lang.Object<method*end> hasPermission(ProceedingJoinPoint<method*start>org.aspectj.lang.ProceedingJoinPoint<method*end> proceedingJoinPoint) throws Throwable<method*start>java.lang.Throwable<method*end> {
if (SecurityContextHolder.getContext<method*start>org.springframework.security.core.context.SecurityContextHolder.getContext<method*end>().getAuthentication<method*start>org.springframework.security.core.context.SecurityContext.getAuthentication<method*end>() == null) {
return proceedingJoinPoint.proceed<method*start>org.aspectj.lang.ProceedingJoinPoint.proceed<method*end>();
}
MethodSignature<method*start>org.aspectj.lang.reflect.MethodSignature<method*end> methodSignature = (MethodSignature<method*start>org.aspectj.lang.reflect.MethodSignature<method*end>) proceedingJoinPoint.getSignature<method*start>org.aspectj.lang.ProceedingJoinPoint.getSignature<method*end>();
DisableHasPermission<method*start>com.sequenceiq.cloudbreak.workspace.repository.DisableHasPermission<method*end> disabled = getAnnotation<method*start>com.sequenceiq.cloudbreak.workspace.HasPermissionService.getAnnotation<method*end>(methodSignature, DisableHasPermission<method*start>com.sequenceiq.cloudbreak.workspace.repository.DisableHasPermission<method*end>.class);
if (disabled != null) {
return proceedingJoinPoint.proceed<method*start>org.aspectj.lang.ProceedingJoinPoint.proceed<method*end>();
}
HasPermission<method*start>com.sequenceiq.cloudbreak.workspace.repository.HasPermission<method*end> annotation = getAnnotation<method*start>com.sequenceiq.cloudbreak.workspace.HasPermissionService.getAnnotation<method*end>(methodSignature, HasPermission<method*start>com.sequenceiq.cloudbreak.workspace.repository.HasPermission<method*end>.class);
validate<method*start>com.sequenceiq.cloudbreak.workspace.HasPermissionService.validate<method*end>(proceedingJoinPoint, annotation);
if (annotation.condition<method*start>com.sequenceiq.cloudbreak.workspace.repository.HasPermission.condition<method*end>() == ConditionType.PRE<method*start>com.sequenceiq.cloudbreak.workspace.repository.ConditionType.PRE<method*end>) {
Object<method*start>java.lang.Object<method*end> target = findTargetByAnnotation<method*start>com.sequenceiq.cloudbreak.workspace.HasPermissionService.findTargetByAnnotation<method*end>(proceedingJoinPoint, annotation);
LOGGER.debug<method*start>org.slf4j.Logger.debug<method*end>("PRE-{} permission for: {}", annotation.permission<method*start>com.sequenceiq.cloudbreak.workspace.repository.HasPermission.permission<method*end>(), target);
authorizationService.hasPermission<method*start>com.sequenceiq.cloudbreak.workspace.AuthorizationService.hasPermission<method*end>(target, annotation.permission<method*start>com.sequenceiq.cloudbreak.workspace.repository.HasPermission.permission<method*end>().name<method*start>com.sequenceiq.cloudbreak.workspace.repository.PermissionType.name<method*end>());
}
Object<method*start>java.lang.Object<method*end> proceed = proceedingJoinPoint.proceed<method*start>org.aspectj.lang.ProceedingJoinPoint.proceed<method*end>();
if (proceed == null) {
logBecauseOfReturnNull<method*start>com.sequenceiq.cloudbreak.workspace.HasPermissionService.logBecauseOfReturnNull<method*end>(methodSignature);
}
if (annotation.condition<method*start>com.sequenceiq.cloudbreak.workspace.repository.HasPermission.condition<method*end>() == ConditionType.POST<method*start>com.sequenceiq.cloudbreak.workspace.repository.ConditionType.POST<method*end>) {
LOGGER.debug<method*start>org.slf4j.Logger.debug<method*end>("POST-{} permission for: {}", annotation.permission<method*start>com.sequenceiq.cloudbreak.workspace.repository.HasPermission.permission<method*end>(), proceed);
authorizationService.hasPermission<method*start>com.sequenceiq.cloudbreak.workspace.AuthorizationService.hasPermission<method*end>(proceed, annotation.permission<method*start>com.sequenceiq.cloudbreak.workspace.repository.HasPermission.permission<method*end>().name<method*start>com.sequenceiq.cloudbreak.workspace.repository.PermissionType.name<method*end>());
}
return proceed;
}
|
public static BundleContext<method*start>org.osgi.framework.BundleContext<method*end> selectContextToRegisterServices(String<method*start>java.lang.String<method*end>[] itfs, BundleContext<method*start>org.osgi.framework.BundleContext<method*end> comp, BundleContext<method*start>org.osgi.framework.BundleContext<method*end> ipojo) {
if (System.getSecurityManager<method*start>java.lang.System.getSecurityManager<method*end>() != null) {
for (String<method*start>java.lang.String<method*end> itf : itfs) {
final Permission<method*start>java.security.Permission<method*end> perm = new ServicePermission(itf, ServicePermission.REGISTER<method*start>org.osgi.framework.ServicePermission.REGISTER<method*end>);
return ipojo;
}
}
}
return comp;
} | conventional | public static BundleContext<method*start>org.osgi.framework.BundleContext<method*end> selectContextToRegisterServices(String<method*start>java.lang.String<method*end>[] itfs, BundleContext<method*start>org.osgi.framework.BundleContext<method*end> comp, BundleContext<method*start>org.osgi.framework.BundleContext<method*end> ipojo) {
if (System.getSecurityManager<method*start>java.lang.System.getSecurityManager<method*end>() != null) {
for (String<method*start>java.lang.String<method*end> itf : itfs) {
final Permission<method*start>java.security.Permission<method*end> perm = new ServicePermission(itf, ServicePermission.REGISTER<method*start>org.osgi.framework.ServicePermission.REGISTER<method*end>);
if (!comp.getBundle<method*start>org.osgi.framework.BundleContext.getBundle<method*end>().hasPermission<method*start>org.osgi.framework.Bundle.hasPermission<method*end>(perm)) {
return ipojo;
}
}
}
return comp;
}
|
@Override
public void execute(Environment env, Map params, TemplateModel[] loopVars, TemplateDirectiveBody body) throws TemplateException, IOException {
String entityTypeIdValue = DataConverter.toString(params.get("entityTypeId"));
String pluginIdValue = DataConverter.toString(params.get("plugin"));
String permissionValue = DataConverter.toString(params.get("permission"));
if ((entityTypeIdValue == null) && (pluginIdValue == null))
throw new TemplateModelException("Missing 'entityTypeId' and/or 'plugin' parameter");
boolean hasPermission = true;
if (entityTypeIdValue != null) {
hasPermission = permissionService.hasPermission(new EntityTypeIdentity(entityTypeIdValue), toEntityTypePermissions(permissionValue));
}
execute(hasPermission, env, body);
} | annotation | @Override<method*start>java.lang.Override<method*end>
public void execute(Environment<method*start>freemarker.core.Environment<method*end> env, @SuppressWarnings<method*start>java.lang.SuppressWarnings<method*end>("rawtypes") Map<method*start>java.util.Map<method*end> params, TemplateModel<method*start>freemarker.template.TemplateModel<method*end>[] loopVars, TemplateDirectiveBody<method*start>freemarker.template.TemplateDirectiveBody<method*end> body) throws TemplateException<method*start>freemarker.template.TemplateException<method*end>, IOException<method*start>java.io.IOException<method*end> {
String<method*start>java.lang.String<method*end> entityTypeIdValue = DataConverter.toString<method*start>org.molgenis.data.DataConverter.toString<method*end>(params.get<method*start>java.util.Map.get<method*end>("entityTypeId"));
String<method*start>java.lang.String<method*end> pluginIdValue = DataConverter.toString<method*start>org.molgenis.data.DataConverter.toString<method*end>(params.get<method*start>java.util.Map.get<method*end>("plugin"));
String<method*start>java.lang.String<method*end> permissionValue = DataConverter.toString<method*start>org.molgenis.data.DataConverter.toString<method*end>(params.get<method*start>java.util.Map.get<method*end>("permission"));
if (permissionValue == null)
throw new TemplateModelException<method*start>freemarker.template.TemplateModelException<method*end>("Missing 'permission' parameter");
if ((entityTypeIdValue == null) && (pluginIdValue == null))
throw new TemplateModelException<method*start>freemarker.template.TemplateModelException<method*end>("Missing 'entityTypeId' and/or 'plugin' parameter");
boolean hasPermission = true;
if (entityTypeIdValue != null) {
hasPermission = permissionService.hasPermission<method*start>org.molgenis.security.core.UserPermissionEvaluator.hasPermission<method*end>(new EntityTypeIdentity<method*start>org.molgenis.data.security.EntityTypeIdentity<method*end>(entityTypeIdValue), toEntityTypePermissions<method*start>org.molgenis.security.freemarker.PermissionDirective.toEntityTypePermissions<method*end>(permissionValue));
}
if ((pluginIdValue != null) && hasPermission) {
hasPermission = permissionService.hasPermission<method*start>org.molgenis.security.core.UserPermissionEvaluator.hasPermission<method*end>(new PluginIdentity<method*start>org.molgenis.data.plugin.model.PluginIdentity<method*end>(pluginIdValue), PluginPermission.VIEW_PLUGIN<method*start>org.molgenis.data.plugin.model.PluginPermission.VIEW_PLUGIN<method*end>);
}
execute(hasPermission, env, body);
}
|
private boolean guestAuthRequestHandler(String appid, HttpServletRequest request, HttpServletResponse response) {
String reqUri = request.getRequestURI();
String method = request.getMethod();
if (StringUtils.isBlank(appid) && Config.getConfigBoolean("clients_can_access_root_app", false)) {
appid = App.id(Config.getRootAppIdentifier());
}
if (!StringUtils.isBlank(appid)) {
App parentApp = Para.getDAO().read(App.id(appid));
SecurityContextHolder.getContext().setAuthentication(new AppAuthentication(parentApp));
RestUtils.returnStatusResponse(response, HttpServletResponse.SC_FORBIDDEN, Utils.formatMessage("You don't have permission to access this resource. [user: {0}, resource: {1} {2}]", "[GUEST]", method, reqUri));
return false;
}
}
RestUtils.returnStatusResponse(response, HttpServletResponse.SC_UNAUTHORIZED, Utils.formatMessage("You don't have permission to access this resource. [{0} {1}]", method, reqUri));
return false;
} | conventional | private boolean guestAuthRequestHandler(String<method*start>java.lang.String<method*end> appid, HttpServletRequest<method*start>javax.servlet.http.HttpServletRequest<method*end> request, HttpServletResponse<method*start>javax.servlet.http.HttpServletResponse<method*end> response) {
String<method*start>java.lang.String<method*end> reqUri = request.getRequestURI<method*start>javax.servlet.http.HttpServletRequest.getRequestURI<method*end>();
String<method*start>java.lang.String<method*end> method = request.getMethod<method*start>javax.servlet.http.HttpServletRequest.getMethod<method*end>();
if (StringUtils.isBlank<method*start>org.apache.commons.lang3.StringUtils.isBlank<method*end>(appid) && Config.getConfigBoolean<method*start>com.erudika.para.utils.Config.getConfigBoolean<method*end>("clients_can_access_root_app", false)) {
appid = App.id<method*start>com.erudika.para.core.App.id<method*end>(Config.getRootAppIdentifier<method*start>com.erudika.para.utils.Config.getRootAppIdentifier<method*end>());
}
if (!StringUtils.isBlank<method*start>org.apache.commons.lang3.StringUtils.isBlank<method*end>(appid)) {
App parentApp = Para.getDAO<method*start>com.erudika.para.Para.getDAO<method*end>().read<method*start>com.erudika.para.persistence.DAO.read<method*end>(App.id<method*start>com.erudika.para.core.App.id<method*end>(appid));
if (hasPermission<method*start>com.erudika.para.security.RestAuthFilter.hasPermission<method*end>(parentApp, null, request)) {
SecurityContextHolder.getContext<method*start>org.springframework.security.core.context.SecurityContextHolder.getContext<method*end>().setAuthentication<method*start>org.springframework.security.core.context.SecurityContext.setAuthentication<method*end>(new AppAuthentication(parentApp));
return true;
} else {
RestUtils.returnStatusResponse<method*start>com.erudika.para.rest.RestUtils.returnStatusResponse<method*end>(response, HttpServletResponse.SC_FORBIDDEN<method*start>javax.servlet.http.HttpServletResponse.SC_FORBIDDEN<method*end>, Utils.formatMessage<method*start>com.erudika.para.utils.Utils.formatMessage<method*end>("You don't have permission to access this resource. " + "[user: {0}, resource: {1} {2}]", "[GUEST]", method, reqUri));
return false;
}
}
RestUtils.returnStatusResponse<method*start>com.erudika.para.rest.RestUtils.returnStatusResponse<method*end>(response, HttpServletResponse.SC_UNAUTHORIZED<method*start>javax.servlet.http.HttpServletResponse.SC_UNAUTHORIZED<method*end>, Utils.formatMessage<method*start>com.erudika.para.utils.Utils.formatMessage<method*end>("You don't have permission to access this resource. [{0} {1}]", method, reqUri));
return false;
}
|
@Override
public void messageOnServerThread(final ToggleHelpMessage<method*start>com.minecolonies.coremod.network.messages.ToggleHelpMessage<method*end> message, final EntityPlayerMP<method*start>net.minecraft.entity.player.EntityPlayerMP<method*end> player) {
final IColony<method*start>com.minecolonies.api.colony.IColony<method*end> colony = IColonyManager<method*start>com.minecolonies.api.colony.IColonyManager<method*end>.getInstance().getColonyByDimension(message.colonyId, message.dimension);
if (colony<method*start>com.minecolonies.coremod.colony.buildings.AbstractCitizenAssignable.colony<method*end> != null) {
colony<method*start>com.minecolonies.coremod.colony.buildings.AbstractCitizenAssignable.colony<method*end>.getProgressManager().togglePrintProgress();
}
} | annotation | @Override
public void messageOnServerThread(final ToggleHelpMessage<method*start>com.minecolonies.coremod.network.messages.ToggleHelpMessage<method*end> message, final EntityPlayerMP<method*start>net.minecraft.entity.player.EntityPlayerMP<method*end> player) {
final IColony<method*start>com.minecolonies.api.colony.IColony<method*end> colony = IColonyManager<method*start>com.minecolonies.api.colony.IColonyManager<method*end>.getInstance().getColonyByDimension(message.colonyId, message.dimension);
if (colony<method*start>com.minecolonies.coremod.colony.buildings.AbstractCitizenAssignable.colony<method*end> != null) {
// Verify player has permission to change this huts settings
if (!colony<method*start>com.minecolonies.coremod.colony.buildings.AbstractCitizenAssignable.colony<method*end>.getPermissions().hasPermission(player, Action<method*start>com.minecolonies.api.colony.permissions.Action<method*end>.MANAGE_HUTS)) {
return;
}
colony<method*start>com.minecolonies.coremod.colony.buildings.AbstractCitizenAssignable.colony<method*end>.getProgressManager().togglePrintProgress();
}
}
|
private boolean execute(CommonSender<method*start>me.confuser.banmanager.common.commands.CommonSender<method*end> sender, String<method*start>java.lang.String<method*end> arguments) {
try {
return this.command.onCommand(sender, this.command.getParser(arguments.split(" ")));
} catch (NoSuchMethodException<method*start>java.lang.NoSuchMethodException<method*end> | IllegalAccessException<method*start>java.lang.IllegalAccessException<method*end> | InstantiationException<method*start>java.lang.InstantiationException<method*end> | InvocationTargetException<method*start>java.lang.reflect.InvocationTargetException<method*end> e) {
e.printStackTrace();
}
return false;
} | conventional | private boolean execute(CommonSender<method*start>me.confuser.banmanager.common.commands.CommonSender<method*end> sender, String<method*start>java.lang.String<method*end> arguments) {
try {
if (sender.hasPermission(command.getPermission())) {
return this.command.onCommand(sender, this.command.getParser(arguments.split(" ")));
} else {
sender.sendMessage("&cYou do not have permission to use this command");
return true;
}
} catch (NoSuchMethodException<method*start>java.lang.NoSuchMethodException<method*end> | IllegalAccessException<method*start>java.lang.IllegalAccessException<method*end> | InstantiationException<method*start>java.lang.InstantiationException<method*end> | InvocationTargetException<method*start>java.lang.reflect.InvocationTargetException<method*end> e) {
e.printStackTrace();
}
return false;
}
|
@Override
public void messageOnServerThread(final TeamColonyColorChangeMessage<method*start>com.minecolonies.coremod.network.messages.TeamColonyColorChangeMessage<method*end> message, final EntityPlayerMP<method*start>net.minecraft.entity.player.EntityPlayerMP<method*end> player) {
final IColony<method*start>com.minecolonies.api.colony.IColony<method*end> colony = IColonyManager<method*start>com.minecolonies.api.colony.IColonyManager<method*end>.getInstance().getColonyByDimension(message.colonyId, message.dimension);
if (colony<method*start>com.minecolonies.coremod.colony.buildings.AbstractCitizenAssignable.colony<method*end> != null) {
// Verify player has permission to change this huts settings
return;
}
colony<method*start>com.minecolonies.coremod.colony.buildings.AbstractCitizenAssignable.colony<method*end>.setColonyColor(TextFormatting<method*start>net.minecraft.util.text.TextFormatting<method*end>.values()[message.colorOrdinal]);
}
} | annotation | @Override
public void messageOnServerThread(final TeamColonyColorChangeMessage<method*start>com.minecolonies.coremod.network.messages.TeamColonyColorChangeMessage<method*end> message, final EntityPlayerMP<method*start>net.minecraft.entity.player.EntityPlayerMP<method*end> player) {
final IColony<method*start>com.minecolonies.api.colony.IColony<method*end> colony = IColonyManager<method*start>com.minecolonies.api.colony.IColonyManager<method*end>.getInstance().getColonyByDimension(message.colonyId, message.dimension);
if (colony<method*start>com.minecolonies.coremod.colony.buildings.AbstractCitizenAssignable.colony<method*end> != null) {
// Verify player has permission to change this huts settings
if (!colony<method*start>com.minecolonies.coremod.colony.buildings.AbstractCitizenAssignable.colony<method*end>.getPermissions().hasPermission(player, Action<method*start>com.minecolonies.api.colony.permissions.Action<method*end>.MANAGE_HUTS)) {
return;
}
colony<method*start>com.minecolonies.coremod.colony.buildings.AbstractCitizenAssignable.colony<method*end>.setColonyColor(TextFormatting<method*start>net.minecraft.util.text.TextFormatting<method*end>.values()[message.colorOrdinal]);
}
}
|
@Override<method*start>java.lang.Override<method*end>
public boolean implies(Permission<method*start>org.apache.shiro.authz.Permission<method*end> p) {
if (p instanceof OperationPermission<method*start>com.manydesigns.portofino.dispatcher.security.OperationPermission<method*end>) {
boolean allowed = false;
for (String<method*start>java.lang.String<method*end> role : roles) {
List<method*start>java.util.List<method*end><Permission<method*start>org.apache.shiro.authz.Permission<method*end>> permissions = getPermissions<method*start>com.manydesigns.portofino.dispatcher.security.RolesPermission.getPermissions<method*end>(role, ((OperationPermission) p).getAllow<method*start>com.manydesigns.portofino.dispatcher.security.OperationPermission.getAllow<method*end>());
}
return false;
}
| conventional | public Collection<method*start>java.util.Collection<method*end><DataSet<method*start>nl.knaw.huygens.timbuctoo.v5.dataset.dto.DataSet<method*end>> getDataSetsWithReadAccess(@Nullable<method*start>javax.annotation.Nullable<method*end> User user) {
List<method*start>java.util.List<method*end><DataSet<method*start>nl.knaw.huygens.timbuctoo.v5.dataset.dto.DataSet<method*end>> dataSetsWithReadAccess = new ArrayList<method*start>java.util.ArrayList<method*end><>();
for (Map<method*start>java.util.Map<method*end><String<method*start>java.lang.String<method*end>, DataSet<method*start>nl.knaw.huygens.timbuctoo.v5.dataset.dto.DataSet<method*end>> userDataSets : dataSetMap.values<method*start>java.util.Map.values<method*end>()) {
for (DataSet<method*start>nl.knaw.huygens.timbuctoo.v5.dataset.dto.DataSet<method*end> dataSet : userDataSets.values<method*start>java.util.Map.values<method*end>()) {
try {
if (permissionFetcher.hasPermission<method*start>nl.knaw.huygens.timbuctoo.v5.security.PermissionFetcher.hasPermission<method*end>(user, dataSet.getMetadata<method*start>nl.knaw.huygens.timbuctoo.v5.dataset.dto.DataSet.getMetadata<method*end>(), READ<method*start>nl.knaw.huygens.timbuctoo.v5.security.dto.Permission.READ<method*end>)) {
dataSetsWithReadAccess.add<method*start>java.util.List.add<method*end>(dataSet);
}
} catch (PermissionFetchingException<method*start>nl.knaw.huygens.timbuctoo.v5.security.exceptions.PermissionFetchingException<method*end> e) {
LOG.error<method*start>org.slf4j.Logger.error<method*end>("Could not fetch read permission", e);
}
}
}
return dataSetsWithReadAccess;
}
|
@TargetApi<method*start>android.annotation.TargetApi<method*end>(Build.VERSION_CODES.M<method*start>android.os.Build.VERSION_CODES.M<method*end>)
public static Observable<method*start>rx.Observable<method*end><Boolean<method*start>java.lang.Boolean<method*end>> promptPermission(Context<method*start>android.content.Context<method*end> context) {
sPermissionObservable<method*start>com.marverenic.music.data.store.MediaStoreUtil.sPermissionObservable<method*end> = BehaviorSubject.create<method*start>rx.subjects.BehaviorSubject.create<method*end>();
}
RxPermissions.getInstance<method*start>com.tbruyelle.rxpermissions.RxPermissions.getInstance<method*end>(context).request<method*start>com.tbruyelle.rxpermissions.RxPermissions.request<method*end>(READ_EXTERNAL_STORAGE<method*start>android.Manifest.permission.READ_EXTERNAL_STORAGE<method*end>, WRITE_EXTERNAL_STORAGE<method*start>android.Manifest.permission.WRITE_EXTERNAL_STORAGE<method*end>).subscribe<method*start>rx.Observable.subscribe<method*end>(sPermissionObservable::onNext, throwable -> {
Timber.i<method*start>timber.log.Timber.i<method*end>(throwable, "Failed to get storage permission");
});
return getPermissionObservable();
} | annotation | @TargetApi<method*start>android.annotation.TargetApi<method*end>(Build.VERSION_CODES.M<method*start>android.os.Build.VERSION_CODES.M<method*end>)
public static Observable<method*start>rx.Observable<method*end><Boolean<method*start>java.lang.Boolean<method*end>> promptPermission(Context<method*start>android.content.Context<method*end> context) {
if (sPermissionObservable<method*start>com.marverenic.music.data.store.MediaStoreUtil.sPermissionObservable<method*end> == null) {
sPermissionObservable<method*start>com.marverenic.music.data.store.MediaStoreUtil.sPermissionObservable<method*end> = BehaviorSubject.create<method*start>rx.subjects.BehaviorSubject.create<method*end>();
}
if (hasPermission(context)) {
if (!sPermissionObservable.hasValue<method*start>rx.subjects.BehaviorSubject.hasValue<method*end>() || !sPermissionObservable.getValue<method*start>rx.subjects.BehaviorSubject.getValue<method*end>()) {
sPermissionObservable.onNext<method*start>rx.subjects.BehaviorSubject.onNext<method*end>(true);
}
return getPermissionObservable();
}
RxPermissions.getInstance<method*start>com.tbruyelle.rxpermissions.RxPermissions.getInstance<method*end>(context).request<method*start>com.tbruyelle.rxpermissions.RxPermissions.request<method*end>(READ_EXTERNAL_STORAGE<method*start>android.Manifest.permission.READ_EXTERNAL_STORAGE<method*end>, WRITE_EXTERNAL_STORAGE<method*start>android.Manifest.permission.WRITE_EXTERNAL_STORAGE<method*end>).subscribe<method*start>rx.Observable.subscribe<method*end>(sPermissionObservable::onNext, throwable -> {
Timber.i<method*start>timber.log.Timber.i<method*end>(throwable, "Failed to get storage permission");
});
return getPermissionObservable();
}
|
@Override
public void messageOnServerThread(final PauseCitizenMessage<method*start>com.minecolonies.coremod.network.messages.PauseCitizenMessage<method*end> message, final EntityPlayerMP<method*start>net.minecraft.entity.player.EntityPlayerMP<method*end> player) {
final IColony<method*start>com.minecolonies.api.colony.IColony<method*end> colony = IColonyManager<method*start>com.minecolonies.api.colony.IColonyManager<method*end>.getInstance().getColonyByDimension(message.colonyId, message.colonyDim);
if (colony<method*start>com.minecolonies.coremod.colony.buildings.AbstractCitizenAssignable.colony<method*end> != null) {
final ICitizenData<method*start>com.minecolonies.api.colony.ICitizenData<method*end> citizen = colony<method*start>com.minecolonies.coremod.colony.buildings.AbstractCitizenAssignable.colony<method*end>.getCitizenManager().getCitizen(message.citizenID);
citizen.setPaused(!citizen.isPaused());
}
}
| annotation | @Override
public void messageOnServerThread(final PauseCitizenMessage<method*start>com.minecolonies.coremod.network.messages.PauseCitizenMessage<method*end> message, final EntityPlayerMP<method*start>net.minecraft.entity.player.EntityPlayerMP<method*end> player) {
final IColony<method*start>com.minecolonies.api.colony.IColony<method*end> colony = IColonyManager<method*start>com.minecolonies.api.colony.IColonyManager<method*end>.getInstance().getColonyByDimension(message.colonyId, message.colonyDim);
if (colony<method*start>com.minecolonies.coremod.colony.buildings.AbstractCitizenAssignable.colony<method*end> != null) {
// Verify player has permission to change this huts settings
if (!colony<method*start>com.minecolonies.coremod.colony.buildings.AbstractCitizenAssignable.colony<method*end>.getPermissions().hasPermission(player, Action<method*start>com.minecolonies.api.colony.permissions.Action<method*end>.MANAGE_HUTS)) {
return;
}
final ICitizenData<method*start>com.minecolonies.api.colony.ICitizenData<method*end> citizen = colony<method*start>com.minecolonies.coremod.colony.buildings.AbstractCitizenAssignable.colony<method*end>.getCitizenManager().getCitizen(message.citizenID);
citizen.setPaused(!citizen.isPaused());
}
}
|
public void remoteTeleport(Player traveler, ServerDoc.Identity destinationServer, @Nullable UUID destinationPlayer) {
Player target = destinationPlayer == null ? null : traveler.getServer().getPlayer(destinationPlayer);
if (target != null) {
localTeleport(traveler, target);
} else if (!isLocal(destinationServer)) {
// TeleportListener will receive this message and call sendToServer
userService.requestTeleport(traveler.getUniqueId(), destinationServer, destinationPlayer);
}
} | conventional | public void remoteTeleport(Player<method*start>org.bukkit.entity.Player<method*end> traveler, ServerDoc.Identity<method*start>tc.oc.api.docs.virtual.ServerDoc.Identity<method*end> destinationServer, @Nullable<method*start>javax.annotation.Nullable<method*end> UUID destinationPlayer) {
if (traveler.hasPermission<method*start>org.bukkit.entity.Player.hasPermission<method*end>(PERMISSION<method*start>tc.oc.commons.bukkit.teleport.Teleporter.PERMISSION<method*end>)) {
Player<method*start>org.bukkit.entity.Player<method*end> target = destinationPlayer == null ? null : traveler.getServer<method*start>org.bukkit.entity.Player.getServer<method*end>().getPlayer(destinationPlayer);
if (target != null) {
localTeleport(traveler, target);
} else if (!isLocal(destinationServer)) {
// TeleportListener will receive this message and call sendToServer
userService.requestTeleport<method*start>tc.oc.api.users.UserService.requestTeleport<method*end>(traveler.getUniqueId<method*start>org.bukkit.entity.Player.getUniqueId<method*end>(), destinationServer, destinationPlayer);
}
}
}
|
@Override
public void onExecute(CommandSender<method*start>org.bukkit.command.CommandSender<method*end> sender, String<method*start>java.lang.String<method*end>[] args) {
if (sender instanceof Player<method*start>org.bukkit.entity.Player<method*end>) {
SlimefunGuide.openGuide<method*start>me.mrCookieSlime.Slimefun.SlimefunGuide.openGuide<method*end>((Player<method*start>org.bukkit.entity.Player<method*end>) sender, book ? SlimefunGuideLayout.BOOK<method*start>io.github.thebusybiscuit.slimefun4.core.guide.SlimefunGuideLayout.BOOK<method*end> : SlimefunGuideLayout.CHEST<method*start>io.github.thebusybiscuit.slimefun4.core.guide.SlimefunGuideLayout.CHEST<method*end>);
} else {
SlimefunPlugin.getLocal<method*start>me.mrCookieSlime.Slimefun.SlimefunPlugin.getLocal<method*end>().sendMessage(sender, "messages.no-permission", true);
}
} else {
SlimefunPlugin.getLocal<method*start>me.mrCookieSlime.Slimefun.SlimefunPlugin.getLocal<method*end>().sendMessage(sender, "messages.only-players", true);
}
}
| annotation | @Override
public void onExecute(CommandSender<method*start>org.bukkit.command.CommandSender<method*end> sender, String<method*start>java.lang.String<method*end>[] args) {
if (sender instanceof Player<method*start>org.bukkit.entity.Player<method*end>) {
if (sender.hasPermission<method*start>org.bukkit.command.CommandSender.hasPermission<method*end>("slimefun.command.open_guide")) {
boolean book = SlimefunPlugin.getCfg<method*start>me.mrCookieSlime.Slimefun.SlimefunPlugin.getCfg<method*end>().getBoolean("guide.default-view-book");
SlimefunGuide.openGuide<method*start>me.mrCookieSlime.Slimefun.SlimefunGuide.openGuide<method*end>((Player<method*start>org.bukkit.entity.Player<method*end>) sender, book ? SlimefunGuideLayout.BOOK<method*start>io.github.thebusybiscuit.slimefun4.core.guide.SlimefunGuideLayout.BOOK<method*end> : SlimefunGuideLayout.CHEST<method*start>io.github.thebusybiscuit.slimefun4.core.guide.SlimefunGuideLayout.CHEST<method*end>);
} else {
SlimefunPlugin.getLocal<method*start>me.mrCookieSlime.Slimefun.SlimefunPlugin.getLocal<method*end>().sendMessage(sender, "messages.no-permission", true);
}
} else {
SlimefunPlugin.getLocal<method*start>me.mrCookieSlime.Slimefun.SlimefunPlugin.getLocal<method*end>().sendMessage(sender, "messages.only-players", true);
}
}
|
@Nonnull<method*start>javax.annotation.Nonnull<method*end>
@Override<method*start>java.lang.Override<method*end>
public AuditableRestAction<method*start>net.dv8tion.jda.api.requests.restaction.AuditableRestAction<method*end><Void<method*start>java.lang.Void<method*end>> modifyNickname(Member member, String nickname) {
JDAImpl jda = getJDA();
return new DeferredRestAction<method*start>net.dv8tion.jda.internal.requests.DeferredRestAction<method*end><>(jda, () -> {
DataObject body = DataObject.empty<method*start>net.dv8tion.jda.api.utils.data.DataObject.empty<method*end>().put<method*start>net.dv8tion.jda.api.utils.data.DataObject.put<method*end>("nick", nickname == null ? "" : nickname);
Route.CompiledRoute<method*start>net.dv8tion.jda.internal.requests.Route.CompiledRoute<method*end> route;
if (member.equals<method*start>net.dv8tion.jda.api.entities.Member.equals<method*end>(getSelfMember()))
route = Route.Guilds.MODIFY_SELF_NICK.compile<method*start>net.dv8tion.jda.internal.requests.Route.compile<method*end>(getId());
else
route = Route.Guilds.MODIFY_MEMBER.compile<method*start>net.dv8tion.jda.internal.requests.Route.compile<method*end>(getId(), member.getUser<method*start>net.dv8tion.jda.api.entities.Member.getUser<method*end>().getId<method*start>net.dv8tion.jda.api.entities.User.getId<method*end>());
return new AuditableRestActionImpl<method*start>net.dv8tion.jda.internal.requests.restaction.AuditableRestActionImpl<method*end><Void<method*start>java.lang.Void<method*end>>(jda, route, body);
}).setCacheCheck<method*start>net.dv8tion.jda.internal.requests.DeferredRestAction.setCacheCheck<method*end>(() -> !Objects.equals<method*start>java.util.Objects.equals<method*end>(nickname, member.getNickname<method*start>net.dv8tion.jda.api.entities.Member.getNickname<method*end>()));
} | annotation | @Nonnull<method*start>javax.annotation.Nonnull<method*end>
@Override<method*start>java.lang.Override<method*end>
public AuditableRestAction<method*start>net.dv8tion.jda.api.requests.restaction.AuditableRestAction<method*end><Void<method*start>java.lang.Void<method*end>> modifyNickname(@Nonnull<method*start>javax.annotation.Nonnull<method*end> Member member, String<method*start>java.lang.String<method*end> nickname) {
Checks.notNull<method*start>net.dv8tion.jda.internal.utils.Checks.notNull<method*end>(member, "Member");
checkGuild<method*start>net.dv8tion.jda.internal.entities.GuildImpl.checkGuild<method*end>(member.getGuild<method*start>net.dv8tion.jda.api.entities.Member.getGuild<method*end>(), "Member");
if (member.equals<method*start>net.dv8tion.jda.api.entities.Member.equals<method*end>(getSelfMember())) {
if (!member.hasPermission<method*start>net.dv8tion.jda.api.entities.Member.hasPermission<method*end>(Permission.NICKNAME_CHANGE<method*start>net.dv8tion.jda.api.Permission.NICKNAME_CHANGE<method*end>) && !member.hasPermission<method*start>net.dv8tion.jda.api.entities.Member.hasPermission<method*end>(Permission.NICKNAME_MANAGE<method*start>net.dv8tion.jda.api.Permission.NICKNAME_MANAGE<method*end>))
throw new InsufficientPermissionException(this, Permission.NICKNAME_CHANGE<method*start>net.dv8tion.jda.api.Permission.NICKNAME_CHANGE<method*end>, "You neither have NICKNAME_CHANGE nor NICKNAME_MANAGE permission!");
} else {
checkPermission<method*start>net.dv8tion.jda.internal.entities.GuildImpl.checkPermission<method*end>(Permission.NICKNAME_MANAGE<method*start>net.dv8tion.jda.api.Permission.NICKNAME_MANAGE<method*end>);
checkPosition<method*start>net.dv8tion.jda.internal.entities.GuildImpl.checkPosition<method*end>(member);
}
JDAImpl jda = getJDA();
return new DeferredRestAction<method*start>net.dv8tion.jda.internal.requests.DeferredRestAction<method*end><>(jda, () -> {
DataObject body = DataObject.empty<method*start>net.dv8tion.jda.api.utils.data.DataObject.empty<method*end>().put<method*start>net.dv8tion.jda.api.utils.data.DataObject.put<method*end>("nick", nickname == null ? "" : nickname);
Route.CompiledRoute<method*start>net.dv8tion.jda.internal.requests.Route.CompiledRoute<method*end> route;
if (member.equals<method*start>net.dv8tion.jda.api.entities.Member.equals<method*end>(getSelfMember()))
route = Route.Guilds.MODIFY_SELF_NICK.compile<method*start>net.dv8tion.jda.internal.requests.Route.compile<method*end>(getId());
else
route = Route.Guilds.MODIFY_MEMBER.compile<method*start>net.dv8tion.jda.internal.requests.Route.compile<method*end>(getId(), member.getUser<method*start>net.dv8tion.jda.api.entities.Member.getUser<method*end>().getId<method*start>net.dv8tion.jda.api.entities.User.getId<method*end>());
return new AuditableRestActionImpl<method*start>net.dv8tion.jda.internal.requests.restaction.AuditableRestActionImpl<method*end><Void<method*start>java.lang.Void<method*end>>(jda, route, body);
}).setCacheCheck<method*start>net.dv8tion.jda.internal.requests.DeferredRestAction.setCacheCheck<method*end>(() -> !Objects.equals<method*start>java.util.Objects.equals<method*end>(nickname, member.getNickname<method*start>net.dv8tion.jda.api.entities.Member.getNickname<method*end>()));
}
|
@Override
public void messageOnServerThread(final GuardRecalculateMessage message, final EntityPlayerMP player) {
final IColony colony = IColonyManager.getInstance().getColonyByDimension(message.colonyId, message.dimension);
if (colony != null) {
final AbstractBuildingGuards building = colony.getBuildingManager().getBuilding(message.buildingId, AbstractBuildingGuards.class);
if (building != null) {
building.calculateMobs();
}
}
} | annotation | @Override
public void messageOnServerThread(final GuardRecalculateMessage<method*start>com.minecolonies.coremod.network.messages.GuardRecalculateMessage<method*end> message, final EntityPlayerMP<method*start>net.minecraft.entity.player.EntityPlayerMP<method*end> player) {
final IColony<method*start>com.minecolonies.api.colony.IColony<method*end> colony = IColonyManager<method*start>com.minecolonies.api.colony.IColonyManager<method*end>.getInstance().getColonyByDimension(message.colonyId, message.dimension);
if (colony<method*start>com.minecolonies.coremod.colony.buildings.AbstractCitizenAssignable.colony<method*end> != null) {
// Verify player has permission to change this huts settings
if (!colony<method*start>com.minecolonies.coremod.colony.buildings.AbstractCitizenAssignable.colony<method*end>.getPermissions().hasPermission(player, Action<method*start>com.minecolonies.api.colony.permissions.Action<method*end>.MANAGE_HUTS)) {
return;
}
@Nullable final AbstractBuildingGuards<method*start>com.minecolonies.coremod.colony.buildings.AbstractBuildingGuards<method*end> building = colony<method*start>com.minecolonies.coremod.colony.buildings.AbstractCitizenAssignable.colony<method*end>.getBuildingManager().getBuilding(message.buildingId, AbstractBuildingGuards<method*start>com.minecolonies.coremod.colony.buildings.AbstractBuildingGuards<method*end>.class);
if (building != null) {
building.calculateMobs();
}
}
}
|
@Override
public void messageOnServerThread(final AssignmentModeMessage<method*start>com.minecolonies.coremod.network.messages.AssignmentModeMessage<method*end> message, final EntityPlayerMP<method*start>net.minecraft.entity.player.EntityPlayerMP<method*end> player) {
final IColony<method*start>com.minecolonies.api.colony.IColony<method*end> colony = IColonyManager<method*start>com.minecolonies.api.colony.IColonyManager<method*end>.getInstance().getColonyByDimension(message.colonyId, message.dimension);
if (colony<method*start>com.minecolonies.coremod.colony.buildings.AbstractCitizenAssignable.colony<method*end> != null) {
@Nullable final BuildingFarmer<method*start>com.minecolonies.coremod.colony.buildings.workerbuildings.BuildingFarmer<method*end> building = colony<method*start>com.minecolonies.coremod.colony.buildings.AbstractCitizenAssignable.colony<method*end>.getBuildingManager().getBuilding(message.buildingId, BuildingFarmer<method*start>com.minecolonies.coremod.colony.buildings.workerbuildings.BuildingFarmer<method*end>.class);
if (building != null) {
building.setAssignManually(message.assignmentMode);
}
}
} | annotation | @Override
public void messageOnServerThread(final AssignmentModeMessage<method*start>com.minecolonies.coremod.network.messages.AssignmentModeMessage<method*end> message, final EntityPlayerMP<method*start>net.minecraft.entity.player.EntityPlayerMP<method*end> player) {
final IColony<method*start>com.minecolonies.api.colony.IColony<method*end> colony = IColonyManager<method*start>com.minecolonies.api.colony.IColonyManager<method*end>.getInstance().getColonyByDimension(message.colonyId, message.dimension);
if (colony<method*start>com.minecolonies.coremod.colony.buildings.AbstractCitizenAssignable.colony<method*end> != null) {
// Verify player has permission to change this huts settings
if (!colony<method*start>com.minecolonies.coremod.colony.buildings.AbstractCitizenAssignable.colony<method*end>.getPermissions().hasPermission(player, Action<method*start>com.minecolonies.api.colony.permissions.Action<method*end>.MANAGE_HUTS)) {
return;
}
@Nullable final BuildingFarmer<method*start>com.minecolonies.coremod.colony.buildings.workerbuildings.BuildingFarmer<method*end> building = colony<method*start>com.minecolonies.coremod.colony.buildings.AbstractCitizenAssignable.colony<method*end>.getBuildingManager().getBuilding(message.buildingId, BuildingFarmer<method*start>com.minecolonies.coremod.colony.buildings.workerbuildings.BuildingFarmer<method*end>.class);
if (building != null) {
building.setAssignManually(message.assignmentMode);
}
}
}
|
private AlmostBoolean<method*start>fr.neatmonster.nocheatplus.compat.AlmostBoolean<method*end> fetchPermission(final RegisteredPermission<method*start>fr.neatmonster.nocheatplus.permissions.RegisteredPermission<method*end> registeredPermission, Player<method*start>org.bukkit.entity.Player<method*end> player) {
if (Bukkit.isPrimaryThread<method*start>org.bukkit.Bukkit.isPrimaryThread<method*end>()) {
if (player == null) {
player = DataManager.getPlayer<method*start>fr.neatmonster.nocheatplus.players.DataManager.getPlayer<method*end>(this.playerId<method*start>fr.neatmonster.nocheatplus.players.PlayerData.playerId<method*end>);
}
}
| conventional | private AlmostBoolean<method*start>fr.neatmonster.nocheatplus.compat.AlmostBoolean<method*end> fetchPermission(final RegisteredPermission<method*start>fr.neatmonster.nocheatplus.permissions.RegisteredPermission<method*end> registeredPermission, Player<method*start>org.bukkit.entity.Player<method*end> player) {
if (Bukkit.isPrimaryThread<method*start>org.bukkit.Bukkit.isPrimaryThread<method*end>()) {
if (player == null) {
player = DataManager.getPlayer<method*start>fr.neatmonster.nocheatplus.players.DataManager.getPlayer<method*end>(this.playerId<method*start>fr.neatmonster.nocheatplus.players.PlayerData.playerId<method*end>);
if (player == null) {
return AlmostBoolean.MAYBE<method*start>fr.neatmonster.nocheatplus.compat.AlmostBoolean.MAYBE<method*end>;
}
}
// Minimal update within the primary thread.
return player.hasPermission<method*start>org.bukkit.entity.Player.hasPermission<method*end>(registeredPermission.getBukkitPermission<method*start>fr.neatmonster.nocheatplus.permissions.RegisteredPermission.getBukkitPermission<method*end>()) ? AlmostBoolean.YES<method*start>fr.neatmonster.nocheatplus.compat.AlmostBoolean.YES<method*end> : AlmostBoolean.NO<method*start>fr.neatmonster.nocheatplus.compat.AlmostBoolean.NO<method*end>;
} else {
requestPermissionUpdate<method*start>fr.neatmonster.nocheatplus.players.PlayerData.requestPermissionUpdate<method*end>(registeredPermission);
/*
* TODO: UNCERTAIN: request related permission right away ? Inefficient in case of exemption.
*
*/
return AlmostBoolean.MAYBE<method*start>fr.neatmonster.nocheatplus.compat.AlmostBoolean.MAYBE<method*end>;
}
}
|
@EventHandler
public void signBreakEvent(BlockBreakEvent event) {
if (event.getBlock().getState() instanceof Sign) {
User user = userHandler.getUser(event.getPlayer().getUniqueId()).orElseThrow(() -> new UserException("Unknown user " + event.getPlayer().getDisplayName() + "(" + event.getPlayer().getUniqueId() + ")"));
Sign sign = (Sign) event.getBlock().getState();
for (int i = 0; i < sign.getLines().length; i++) {
String line = sign.getLines()[i];
for (String key : signHandler.getSignPlaceholders().getPlaceHolders().keySet()) {
if (line.contains("%" + key + "%")) {
event.setCancelled(true);
Lang.msg(user, LangKey.SIGNS_BREAK_NO_PERM, key, placeHolderSignBreak.getRole().getName());
return;
}
}
for (String key : signHandler.getSignButtons().getButtons().keySet()) {
if (line.contains("%" + key + "%")) {
event.setCancelled(true);
Lang.msg(user, LangKey.SIGNS_BREAK_NO_PERM, key, buttonSignBreak.getRole().getName());
return;
}
}
}
}
} | annotation | @EventHandler
public void signBreakEvent(@Nonnull<method*start>javax.annotation.Nonnull<method*end> BlockBreakEvent event) {
// is block a sign?
if (event.getBlock().getState() instanceof Sign<method*start>org.bukkit.block.Sign<method*end>) {
User<method*start>com.voxelgameslib.voxelgameslib.components.user.User<method*end> user = userHandler.getUser(event.getPlayer().getUniqueId()).orElseThrow(() -> new UserException("Unknown user " + event.getPlayer().getDisplayName() + "(" + event.getPlayer().getUniqueId() + ")"));
Sign<method*start>org.bukkit.block.Sign<method*end> sign = (Sign<method*start>org.bukkit.block.Sign<method*end>) event.getBlock().getState();
for (int i = 0; i < sign.getLines().length; i++) {
String<method*start>java.lang.String<method*end> line = sign.getLines()[i];
for (String<method*start>java.lang.String<method*end> key : signHandler.getSignPlaceholders().getPlaceHolders().keySet()) {
if (line.contains("%" + key + "%")) {
// has user permission for that?
if (user.hasPermission(placeHolderSignBreak)) {
Lang<method*start>com.voxelgameslib.voxelgameslib.internal.lang.Lang<method*end>.msg(user, LangKey<method*start>com.voxelgameslib.voxelgameslib.internal.lang.LangKey<method*end>.SIGNS_BREAK_SUCCESS, key);
event.getBlock().setType(Material<method*start>org.bukkit.Material<method*end>.AIR);
return;
} else {
event.setCancelled(true);
Lang<method*start>com.voxelgameslib.voxelgameslib.internal.lang.Lang<method*end>.msg(user, LangKey<method*start>com.voxelgameslib.voxelgameslib.internal.lang.LangKey<method*end>.SIGNS_BREAK_NO_PERM, key, placeHolderSignBreak.getRole().getName());
return;
}
}
}
for (String<method*start>java.lang.String<method*end> key : signHandler.getSignButtons().getButtons().keySet()) {
if (line.contains("%" + key + "%")) {
// has user permission for that?
if (user.hasPermission(buttonSignBreak)) {
Lang<method*start>com.voxelgameslib.voxelgameslib.internal.lang.Lang<method*end>.msg(user, LangKey<method*start>com.voxelgameslib.voxelgameslib.internal.lang.LangKey<method*end>.SIGNS_BREAK_SUCCESS, key);
event.getBlock().setType(Material<method*start>org.bukkit.Material<method*end>.AIR);
return;
} else {
event.setCancelled(true);
Lang<method*start>com.voxelgameslib.voxelgameslib.internal.lang.Lang<method*end>.msg(user, LangKey<method*start>com.voxelgameslib.voxelgameslib.internal.lang.LangKey<method*end>.SIGNS_BREAK_NO_PERM, key, buttonSignBreak.getRole().getName());
return;
}
}
}
}
}
}
|
public boolean canDeliver(final Event<method*start>org.osgi.service.event.Event<method*end> event) {
final Bundle<method*start>org.osgi.framework.Bundle<method*end> bundle = reference.getBundle<method*start>org.osgi.framework.ServiceReference.getBundle<method*end>();
// is service unregistered?
if (bundle == null) {
return false;
}
// filter match
final Filter eventFilter = this.filter<method*start>org.apache.felix.eventadmin.impl.handler.EventHandlerProxy.filter<method*end>;
if (eventFilter != null && !event.matches<method*start>org.osgi.service.event.Event.matches<method*end>(eventFilter)) {
return false;
}
return true;
} | conventional | public boolean canDeliver(final Event<method*start>org.osgi.service.event.Event<method*end> event) {
if (this.blacklisted<method*start>org.apache.felix.eventadmin.impl.handler.EventHandlerProxy.blacklisted<method*end>) {
return false;
}
final Bundle<method*start>org.osgi.framework.Bundle<method*end> bundle = reference.getBundle<method*start>org.osgi.framework.ServiceReference.getBundle<method*end>();
// is service unregistered?
if (bundle == null) {
return false;
}
// filter match
final Filter eventFilter = this.filter<method*start>org.apache.felix.eventadmin.impl.handler.EventHandlerProxy.filter<method*end>;
if (eventFilter != null && !event.matches<method*start>org.osgi.service.event.Event.matches<method*end>(eventFilter)) {
return false;
}
// permission check
final Object<method*start>java.lang.Object<method*end> p = PermissionsUtil.createSubscribePermission<method*start>org.apache.felix.eventadmin.impl.security.PermissionsUtil.createSubscribePermission<method*end>(event.getTopic<method*start>org.osgi.service.event.Event.getTopic<method*end>());
if (p != null && !bundle.hasPermission<method*start>org.osgi.framework.Bundle.hasPermission<method*end>(p)) {
return false;
}
return true;
}
|
@Override
public void messageOnServerThread(final ChangeDeliveryPriorityStateMessage<method*start>com.minecolonies.coremod.network.messages.ChangeDeliveryPriorityStateMessage<method*end> message, final EntityPlayerMP<method*start>net.minecraft.entity.player.EntityPlayerMP<method*end> player) {
final IColony<method*start>com.minecolonies.api.colony.IColony<method*end> colony = IColonyManager<method*start>com.minecolonies.api.colony.IColonyManager<method*end>.getInstance().getColonyByDimension(message.colonyId, message.dimension);
final IBuilding building = colony<method*start>com.minecolonies.coremod.colony.buildings.AbstractCitizenAssignable.colony<method*end>.getBuildingManager().getBuilding(message.buildingId);
if (building instanceof AbstractBuildingWorker<method*start>com.minecolonies.coremod.colony.buildings.AbstractBuildingWorker<method*end>) {
building.alterPriorityState();
building.markDirty();
}
}
} | annotation | @Override
public void messageOnServerThread(final ChangeDeliveryPriorityStateMessage<method*start>com.minecolonies.coremod.network.messages.ChangeDeliveryPriorityStateMessage<method*end> message, final EntityPlayerMP<method*start>net.minecraft.entity.player.EntityPlayerMP<method*end> player) {
final IColony<method*start>com.minecolonies.api.colony.IColony<method*end> colony = IColonyManager<method*start>com.minecolonies.api.colony.IColonyManager<method*end>.getInstance().getColonyByDimension(message.colonyId, message.dimension);
if (colony<method*start>com.minecolonies.coremod.colony.buildings.AbstractCitizenAssignable.colony<method*end> != null && colony<method*start>com.minecolonies.coremod.colony.buildings.AbstractCitizenAssignable.colony<method*end>.getPermissions().hasPermission(player, Action<method*start>com.minecolonies.api.colony.permissions.Action<method*end>.ACCESS_HUTS)) {
// Verify player has permission to change this huts settings
if (!colony<method*start>com.minecolonies.coremod.colony.buildings.AbstractCitizenAssignable.colony<method*end>.getPermissions().hasPermission(player, Action<method*start>com.minecolonies.api.colony.permissions.Action<method*end>.MANAGE_HUTS)) {
return;
}
final IBuilding building = colony<method*start>com.minecolonies.coremod.colony.buildings.AbstractCitizenAssignable.colony<method*end>.getBuildingManager().getBuilding(message.buildingId);
if (building instanceof AbstractBuildingWorker<method*start>com.minecolonies.coremod.colony.buildings.AbstractBuildingWorker<method*end>) {
building.alterPriorityState();
building.markDirty();
}
}
}
|
private static ItemStack<method*start>org.bukkit.inventory.ItemStack<method*end> getDisplayItem(Player<method*start>org.bukkit.entity.Player<method*end> p, boolean isSlimefunRecipe, ItemStack<method*start>org.bukkit.inventory.ItemStack<method*end> item) {
if (isSlimefunRecipe) {
SlimefunItem<method*start>me.mrCookieSlime.Slimefun.Objects.SlimefunItem.SlimefunItem<method*end> slimefunItem = SlimefunItem.getByItem<method*start>me.mrCookieSlime.Slimefun.Objects.SlimefunItem.SlimefunItem.getByItem<method*end>(item);
Slimefun.hasUnlocked<method*start>me.mrCookieSlime.Slimefun.api.Slimefun.hasUnlocked<method*end>(p, slimefunItem, false) ? item : new CustomItem<method*start>io.github.thebusybiscuit.cscorelib2.item.CustomItem<method*end>(Material.BARRIER<method*start>org.bukkit.Material.BARRIER<method*end>, ItemUtils.getItemName<method*start>io.github.thebusybiscuit.cscorelib2.inventory.ItemUtils.getItemName<method*end>(item), "&4&lLOCKED", "", lore);
} else {
return item;
}
}
| conventional | private static ItemStack<method*start>org.bukkit.inventory.ItemStack<method*end> getDisplayItem(Player<method*start>org.bukkit.entity.Player<method*end> p, boolean isSlimefunRecipe, ItemStack<method*start>org.bukkit.inventory.ItemStack<method*end> item) {
if (isSlimefunRecipe) {
SlimefunItem<method*start>me.mrCookieSlime.Slimefun.Objects.SlimefunItem.SlimefunItem<method*end> slimefunItem = SlimefunItem.getByItem<method*start>me.mrCookieSlime.Slimefun.Objects.SlimefunItem.SlimefunItem.getByItem<method*end>(item);
if (slimefunItem == null)
return item;
String<method*start>java.lang.String<method*end> lore = Slimefun.hasPermission<method*start>me.mrCookieSlime.Slimefun.api.Slimefun.hasPermission<method*end>(p, slimefunItem, false) ? "&rNeeds to be unlocked elsewhere" : "&rNo Permission";
return Slimefun.hasUnlocked<method*start>me.mrCookieSlime.Slimefun.api.Slimefun.hasUnlocked<method*end>(p, slimefunItem, false) ? item : new CustomItem<method*start>io.github.thebusybiscuit.cscorelib2.item.CustomItem<method*end>(Material.BARRIER<method*start>org.bukkit.Material.BARRIER<method*end>, ItemUtils.getItemName<method*start>io.github.thebusybiscuit.cscorelib2.inventory.ItemUtils.getItemName<method*end>(item), "&4&lLOCKED", "", lore);
} else {
return item;
}
}
|
@RequirePOST
public FormValidation<method*start>hudson.util.FormValidation<method*end> doTestZookeeperConnection(@QueryParameter("zookeeperURL") final String<method*start>java.lang.String<method*end> zookeeperURL) throws IOException<method*start>java.io.IOException<method*end>, ServletException<method*start>javax.servlet.ServletException<method*end> {
try {
String<method*start>java.lang.String<method*end>[] hostport = zookeeperURL.split(":");
String<method*start>java.lang.String<method*end> host = hostport[0];
int port = Integer<method*start>java.lang.Integer<method*end>.parseInt(hostport[1]);
testConnection<method*start>io.jenkins.plugins.remotingkafka.GlobalKafkaConfiguration.testConnection<method*end>(host, port);
return FormValidation<method*start>hudson.util.FormValidation<method*end>.ok("Success");
} catch (Exception<method*start>java.lang.Exception<method*end> e) {
return FormValidation<method*start>hudson.util.FormValidation<method*end>.error("Connection error : " + e.getMessage());
}
} | annotation | @RequirePOST
public FormValidation<method*start>hudson.util.FormValidation<method*end> doTestZookeeperConnection(@QueryParameter("zookeeperURL") final String<method*start>java.lang.String<method*end> zookeeperURL) throws IOException<method*start>java.io.IOException<method*end>, ServletException<method*start>javax.servlet.ServletException<method*end> {
if (!Jenkins<method*start>jenkins.model.Jenkins<method*end>.get().hasPermission(Jenkins<method*start>jenkins.model.Jenkins<method*end>.ADMINISTER)) {
return FormValidation<method*start>hudson.util.FormValidation<method*end>.error("Need admin permission to perform this action");
}
try {
String<method*start>java.lang.String<method*end>[] hostport = zookeeperURL.split(":");
String<method*start>java.lang.String<method*end> host = hostport[0];
int port = Integer<method*start>java.lang.Integer<method*end>.parseInt(hostport[1]);
testConnection<method*start>io.jenkins.plugins.remotingkafka.GlobalKafkaConfiguration.testConnection<method*end>(host, port);
return FormValidation<method*start>hudson.util.FormValidation<method*end>.ok("Success");
} catch (Exception<method*start>java.lang.Exception<method*end> e) {
return FormValidation<method*start>hudson.util.FormValidation<method*end>.error("Connection error : " + e.getMessage());
}
}
|
@Override
public void messageOnServerThread(final AssignFieldMessage message, final EntityPlayerMP player) {
final IColony colony = IColonyManager.getInstance().getColonyByDimension(message.colonyId, message.dimension);
if (colony != null) {
@Nullable final BuildingFarmer building = colony.getBuildingManager().getBuilding(message.buildingId, BuildingFarmer.class);
if (building != null) {
if (message.assign) {
building.assignField(message.field);
} else {
building.freeField(message.field);
}
}
}
} | annotation | @Override
public void messageOnServerThread(final AssignFieldMessage<method*start>com.minecolonies.coremod.network.messages.AssignFieldMessage<method*end> message, final EntityPlayerMP<method*start>net.minecraft.entity.player.EntityPlayerMP<method*end> player) {
final IColony<method*start>com.minecolonies.api.colony.IColony<method*end> colony = IColonyManager<method*start>com.minecolonies.api.colony.IColonyManager<method*end>.getInstance().getColonyByDimension(message.colonyId, message.dimension);
if (colony<method*start>com.minecolonies.coremod.colony.buildings.AbstractCitizenAssignable.colony<method*end> != null) {
// Verify player has permission to change this huts settings
if (!colony<method*start>com.minecolonies.coremod.colony.buildings.AbstractCitizenAssignable.colony<method*end>.getPermissions().hasPermission(player, Action<method*start>com.minecolonies.api.colony.permissions.Action<method*end>.MANAGE_HUTS)) {
return;
}
@Nullable final BuildingFarmer<method*start>com.minecolonies.coremod.colony.buildings.workerbuildings.BuildingFarmer<method*end> building = colony<method*start>com.minecolonies.coremod.colony.buildings.AbstractCitizenAssignable.colony<method*end>.getBuildingManager().getBuilding(message.buildingId, BuildingFarmer<method*start>com.minecolonies.coremod.colony.buildings.workerbuildings.BuildingFarmer<method*end>.class);
if (building != null) {
if (message.assign) {
building.assignField(message.field);
} else {
building.freeField(message.field);
}
}
}
}
|
@Override
public boolean execute(CommandSender sender, String currentAlias, String[] args) {
if (args.length < 2) {
sender.sendMessage(ChatColor.RED + "Incorrect usage. Correct usage:\n" + usageMessage);
return false;
}
int value;
if (args[0].equals("set")) {
sender.sendMessage(ChatColor.RED + "You don't have permission to set the time");
return true;
}
if (args[1].equals("day")) {
value = 0;
} else if (args[1].equals("night")) {
value = 12500;
} else {
value = getInteger(sender, args[1], 0);
}
for (World world : Bukkit.getWorlds()) {
world.setTime(value);
}
Command.broadcastCommandMessage(sender, "Set time to " + value);
} else if (args[0].equals("add")) {
sender.sendMessage(ChatColor.RED + "You don't have permission to set the time");
return true;
}
value = getInteger(sender, args[1], 0);
for (World world : Bukkit.getWorlds()) {
world.setFullTime(world.getFullTime() + value);
}
Command.broadcastCommandMessage(sender, "Added " + value + " to time");
} else {
sender.sendMessage("Unknown method. Usage: " + usageMessage);
}
return true;
} | annotation | @Override<method*start>java.lang.Override<method*end>
public boolean execute(CommandSender<method*start>org.bukkit.command.CommandSender<method*end> sender, String<method*start>java.lang.String<method*end> currentAlias, String<method*start>java.lang.String<method*end>[] args) {
if (args.length<method*start>java.lang.String[].length<method*end> < 2) {
sender.sendMessage<method*start>org.bukkit.command.CommandSender.sendMessage<method*end>(ChatColor.RED<method*start>org.bukkit.ChatColor.RED<method*end> + "Incorrect usage. Correct usage:\n" + usageMessage<method*start>org.bukkit.command.Command.usageMessage<method*end>);
return false;
}
int value;
if (args[0].equals<method*start>java.lang.String.equals<method*end>("set")) {
if (!sender.hasPermission<method*start>org.bukkit.command.CommandSender.hasPermission<method*end>("bukkit.command.time.set")) {
sender.sendMessage<method*start>org.bukkit.command.CommandSender.sendMessage<method*end>(ChatColor.RED<method*start>org.bukkit.ChatColor.RED<method*end> + "You don't have permission to set the time");
return true;
}
if (args[1].equals<method*start>java.lang.String.equals<method*end>("day")) {
value = 0;
} else if (args[1].equals<method*start>java.lang.String.equals<method*end>("night")) {
value = 12500;
} else {
value = getInteger<method*start>org.bukkit.command.defaults.VanillaCommand.getInteger<method*end>(sender, args[1], 0);
}
for (World world : Bukkit.getWorlds<method*start>org.bukkit.Bukkit.getWorlds<method*end>()) {
world.setTime<method*start>org.bukkit.World.setTime<method*end>(value);
}
Command.broadcastCommandMessage<method*start>org.bukkit.command.Command.broadcastCommandMessage<method*end>(sender, "Set time to " + value);
} else if (args[0].equals<method*start>java.lang.String.equals<method*end>("add")) {
if (!sender.hasPermission<method*start>org.bukkit.command.CommandSender.hasPermission<method*end>("bukkit.command.time.add")) {
sender.sendMessage<method*start>org.bukkit.command.CommandSender.sendMessage<method*end>(ChatColor.RED<method*start>org.bukkit.ChatColor.RED<method*end> + "You don't have permission to set the time");
return true;
}
value = getInteger<method*start>org.bukkit.command.defaults.VanillaCommand.getInteger<method*end>(sender, args[1], 0);
for (World world : Bukkit.getWorlds<method*start>org.bukkit.Bukkit.getWorlds<method*end>()) {
world.setFullTime<method*start>org.bukkit.World.setFullTime<method*end>(world.getFullTime<method*start>org.bukkit.World.getFullTime<method*end>() + value);
}
Command.broadcastCommandMessage<method*start>org.bukkit.command.Command.broadcastCommandMessage<method*end>(sender, "Added " + value + " to time");
} else {
sender.sendMessage<method*start>org.bukkit.command.CommandSender.sendMessage<method*end>("Unknown method. Usage: " + usageMessage<method*start>org.bukkit.command.Command.usageMessage<method*end>);
}
return true;
}
|
@Override
public void messageOnServerThread(final AssignFilterableItemMessagecom.minecolonies.coremod.network.messages.AssignFilterableItemMessage message, final EntityPlayerMPnet.minecraft.entity.player.EntityPlayerMP player) {
final IColonycom.minecolonies.api.colony.IColony colony = IColonyManagercom.minecolonies.api.colony.IColonyManager.getInstance().getColonyByDimension(message.colonyId, message.dimension);
if (colonycom.minecolonies.coremod.colony.buildings.AbstractCitizenAssignable.colony != null) {
@Nullable final AbstractFilterableListBuildingcom.minecolonies.coremod.colony.buildings.AbstractFilterableListBuilding building = colonycom.minecolonies.coremod.colony.buildings.AbstractCitizenAssignable.colony.getBuildingManager().getBuilding(message.buildingId, AbstractFilterableListBuildingcom.minecolonies.coremod.colony.buildings.AbstractFilterableListBuilding.class);
if (building != null) {
if (message.assign) {
building.addItem(message.id, message.item);
} else {
building.removeItem(message.id, message.item);
}
}
}
} | annotation | @Override
public void messageOnServerThread(final AssignFilterableItemMessage<method*start>com.minecolonies.coremod.network.messages.AssignFilterableItemMessage<method*end> message, final EntityPlayerMP<method*start>net.minecraft.entity.player.EntityPlayerMP<method*end> player) {
final IColony<method*start>com.minecolonies.api.colony.IColony<method*end> colony = IColonyManager<method*start>com.minecolonies.api.colony.IColonyManager<method*end>.getInstance().getColonyByDimension(message.colonyId, message.dimension);
if (colony<method*start>com.minecolonies.coremod.colony.buildings.AbstractCitizenAssignable.colony<method*end> != null) {
// Verify player has permission to change this huts settings
if (!colony<method*start>com.minecolonies.coremod.colony.buildings.AbstractCitizenAssignable.colony<method*end>.getPermissions().hasPermission(player, Action<method*start>com.minecolonies.api.colony.permissions.Action<method*end>.MANAGE_HUTS)) {
return;
}
@Nullable final AbstractFilterableListBuilding<method*start>com.minecolonies.coremod.colony.buildings.AbstractFilterableListBuilding<method*end> building = colony<method*start>com.minecolonies.coremod.colony.buildings.AbstractCitizenAssignable.colony<method*end>.getBuildingManager().getBuilding(message.buildingId, AbstractFilterableListBuilding<method*start>com.minecolonies.coremod.colony.buildings.AbstractFilterableListBuilding<method*end>.class);
if (building != null) {
if (message.assign) {
building.addItem(message.id, message.item);
} else {
building.removeItem(message.id, message.item);
}
}
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.