public override bool BeforeSaveSettings(RoleSettings roleSettings)
{
if (My.IsOwner)
{
PermissionSettings settings = SettingManager.CloneSetttings <PermissionSettings>(AllSettings.Current.PermissionSettings);
settings.ContentPermissionLimit.LimitType = _Request.Get <PermissionLimitType>("ContentPermissionLimit", Method.Post, PermissionLimitType.RoleLevelLowerMe);
settings.UserPermissionLimit.LimitType = _Request.Get <PermissionLimitType>("UserPermissionLimit", Method.Post, PermissionLimitType.RoleLevelLowerMe);
if (settings.ContentPermissionLimit.LimitType == PermissionLimitType.ExcludeCustomRoles)
{
string key = "content.{0}.{1}";
GetLimitRoleList(key, settings.ContentPermissionLimit);
}
if (settings.UserPermissionLimit.LimitType == PermissionLimitType.ExcludeCustomRoles)
{
string key = "user.{0}.{1}";
GetLimitRoleList(key, settings.UserPermissionLimit);
}
SettingManager.SaveSettings(settings);
}
return(true);
}
internal static IList <int> GetActionPrivilegeIds(PermissionSettings permissionSettings)
{
var privilegeIds = new List <int>();
if (permissionSettings.Action == ActionEnum.DeleteProperty)
{
privilegeIds.Add((int)CostumerPrivilege.DeleteProperty);
}
else if (permissionSettings.Action == ActionEnum.SendingDocuments)
{
privilegeIds.Add((int)PropertyPrivilege.SendDocument);
}
else if (permissionSettings.Action == ActionEnum.CheckBiddingStatus)
{
privilegeIds.Add((int)CostumerPrivilege.ScheduleViewing);
privilegeIds.Add((int)CostumerPrivilege.MakeOffer);
}
else if (permissionSettings.Action == ActionEnum.ChangeBiddingPrice)
{
privilegeIds.Add((int)AgentPrivilege.ChangeBiddingPrice);
}
else if (permissionSettings.Action == ActionEnum.MenuScheduleViewing)
{
privilegeIds.Add((int)CostumerPrivilege.ScheduleViewing);
}
else if (permissionSettings.Action == ActionEnum.MakeOffer)
{
privilegeIds.Add((int)CostumerPrivilege.MakeOffer);
}
return(privilegeIds);
}
//#region TryPay
//private readonly Hash<int, int> costs = new Hash<int, int>();
//private readonly Hash<string , int> missingDictionary = new Hash<string, int>();
//private readonly HashSet<BuildingBlock> toRemove = new HashSet<BuildingBlock>();
//private bool TryPay(BasePlayer player, BuildingGrade.Enum targetGrade, out string missingResources) {
// FindUpgradeCosts(player, targetGrade);
// if (!CanPay(player, out missingResources)) {
// return false;
// }
// var collect = Pool.GetList<Item>();
// foreach (var entry in costs) {
// player.inventory.Take(collect, entry.Key, entry.Value);
// player.Command(string.Concat("note.inv ", entry.Key, " ", entry.Value * -1f));
// }
// foreach (var item in collect) {
// item.Remove();
// }
// Pool.FreeList(ref collect);
// missingResources = null;
// return true;
//}
//private bool CanPay(BasePlayer player, out string missingResources) {
// foreach (var entry in costs) {
// if (entry.Value <= 0) continue;
// var missingAmount = entry.Value - player.inventory.GetAmount(entry.Key);
// if (missingAmount <= 0) continue;
// var displayName= ItemManager.FindItemDefinition(entry.Key)?.displayName.english;
// if (string.IsNullOrEmpty(displayName)) displayName = entry.Key.ToString();
// missingDictionary[displayName] += missingAmount;
// }
// if (missingDictionary.Count > 0) {
// StringBuilder stringBuilder = Pool.Get<StringBuilder>();
// foreach (var entry in missingDictionary) {
// stringBuilder.AppendLine(Lang("MissingResourceFormat", player.UserIDString, entry.Key, entry.Value));
// }
// missingResources = stringBuilder.ToString();
// stringBuilder.Clear();
// missingDictionary.Clear();
// Pool.Free(ref stringBuilder);
// return false;
// }
// missingResources = null;
// return true;
//}
//private void FindUpgradeCosts(BasePlayer player, BuildingGrade.Enum targetGrade) {
// var autoGrade = targetGrade == BuildingGrade.Enum.None;
// foreach (var buildingBlock in allBuildingBlocks) {
// if (buildingBlock == null || buildingBlock.IsDestroyed) {
// toRemove.Add(buildingBlock);
// continue;
// }
// BuildingGrade.Enum grade = targetGrade;
// if (CheckBuildingGrade(buildingBlock, false, ref grade)) {
// if (!autoGrade || tempGrantedGrades.Contains(grade)) {
// if (!CanUpgrade(buildingBlock, player, grade)) {
// toRemove.Add(buildingBlock);
// continue;
// }
// }
// }
// var costToBuild = buildingBlock.blockDefinition.grades[(int)grade].costToBuild;
// foreach (var itemAmount in costToBuild) {
// costs[itemAmount.itemid] += (int)itemAmount.amount;
// }
// }
// foreach (var buildingBlock in toRemove) {
// allBuildingBlocks.Remove(buildingBlock);
// }
// toRemove.Clear();
//}
//#endregion TryPay
#endregion Methods
#endregion Building Grade Control
#region Helpers
private static BuildingBlock GetLookingAtBuildingBlock(BasePlayer player, PermissionSettings permS)
{
RaycastHit raycastHit;
var flag = Physics.Raycast(player.eyes.HeadRay(), out raycastHit, permS.distance, Rust.Layers.Mask.Construction);
return(flag ? raycastHit.GetEntity() as BuildingBlock : null);
}
public void SetUp()
{
this.permissionSettings = new PermissionSettings();
this.mockPermission = Substitute.For <IPermissionRule>();
this.permissionRules = new List <IPermissionRule>()
{
this.mockPermission
};
}
public void IsVisible_ShouldAlwaysEqualToTrue()
{
// Arrange
var permissionValue = new PermissionSettings();
// Act
var isVisible = this.sut.IsVisible(permissionValue);
// Assert
Assert.That(isVisible, Is.True);
}
private void InitializeVariables()
{
this.callContext = new CallContext();
this.roomUserPrivileges = new List <PropertyUserPrivilege>();
this.permissionAuthorizer = Substitute.For <IPermissionAuthorizer>();
this.permissionSettings = new PermissionSettings()
{
CallContext = callContext,
PrivilegesByUserRoom = this.roomUserPrivileges
};
this.sut = new CostumerPermissionRule(this.permissionAuthorizer);
}
public void IsVisible_WhenBiddingIsLockedIsFalse_ShouldIsEnabledEqualToTrue()
{
// Arrange
var permissionValue = new PermissionSettings()
{
IsBiddingLocked = false
};
// Act
var isVisible = this.sut.IsVisible(permissionValue);
// Assert
Assert.That(isVisible, Is.True);
}
public void IsEnabled_WhenPropertyStatusIsNot5_ShouldIsEnabledEqualToTrue(int propertyStatusTypeId)
{
// Arrange
var permissionValue = new PermissionSettings()
{
PropertyStatusTypeId = propertyStatusTypeId
};
// Act
var isEnabled = this.sut.IsEnabled(permissionValue);
// Assert
Assert.That(isEnabled, Is.True);
}
public void IsEnabled_WhenPropertyStatusIs5_ShouldIsEnabledEqualToFalse()
{
// Arrange
var permissionValue = new PermissionSettings()
{
PropertyStatusTypeId = 5
};
// Act
var isEnabled = this.sut.IsEnabled(permissionValue);
// Assert
Assert.That(isEnabled, Is.False);
}
public void IsVisible_ShouldReverseOfIsPrivate(bool isPrivate)
{
// Arrange
var permissionValue = new PermissionSettings()
{
IsPrivate = isPrivate
};
// Act
var isVisible = this.sut.IsVisible(permissionValue);
// Assert
Assert.That(isVisible, Is.EqualTo(!isPrivate));
}
public void IsEnabled_WhenBiddingIsLocked_ShouldIsEnabledEqualToFalse()
{
// Arrange
var permissionValue = new PermissionSettings()
{
IsBiddingLocked = true
};
// Act
var isEnabled = this.sut.IsEnabled(permissionValue);
// Assert
Assert.That(isEnabled, Is.False);
}
GetActionPrivilegeIds_WhenActionIsCheckBiddingStatus_ShouldPrivilegesIdContains2ItemsAndValuesAre1And2()
{
// Arrange
var permissionSettings = new PermissionSettings()
{
Action = ActionEnum.CheckBiddingStatus
};
// Act
var actionPrivilegeIds = CostumerPermissionRule.GetActionPrivilegeIds(permissionSettings);
// Assert
Assert.That(actionPrivilegeIds, Has.Exactly(1).EqualTo(1)
.And.Exactly(1).EqualTo(2));
}
GetActionPrivilegeIds_WhenActionEnumIsOnlyDependsOnePrivilege_ShouldListContains1MemberWhichExactlyTheGivenPrivilege(
ActionEnum actionEnum, int privilegeId)
{
// Arrange
var permissionSettings = new PermissionSettings()
{
Action = actionEnum
};
// Act
var actionPrivilegeIds = CostumerPermissionRule.GetActionPrivilegeIds(permissionSettings);
// Assert
Assert.That(actionPrivilegeIds, Has.Exactly(1).EqualTo(privilegeId));
}
private PermissionSettings GetPermissionS(BasePlayer player)
{
int priority = 0;
PermissionSettings permissionSettings = null;
foreach (var entry in configData.permS)
{
if (entry.Value.priority >= priority && permission.UserHasPermission(player.UserIDString, entry.Key))
{
priority = entry.Value.priority;
permissionSettings = entry.Value;
}
}
return(permissionSettings ?? new PermissionSettings());
}
public void ApplyRule_WhenThereAreTwoRulesAndTheFirstOneIsVisibleIsFalse_ShouldSecondRuleIsVisibleCalledNever()
{
// Arrange
this.mockPermission.IsEnabled(this.permissionSettings).Returns(false);
var secondMockedRule = Substitute.For <IPermissionRule>();
this.permissionRules.Add(secondMockedRule);
var restrictedPermission = new RestrictedPermission(this.permissionSettings, this.permissionRules);
var permissionSettings = new PermissionSettings();
// Act
restrictedPermission.ApplyRules();
// Assert
secondMockedRule.DidNotReceive().IsVisible(this.permissionSettings);
}
internal virtual bool IsVisibleAndEnabled(PermissionSettings permissionSettings)
{
var privilegeIds = GetActionPrivilegeIds(permissionSettings);
foreach (var privilegeId in privilegeIds)
{
var isAuthorized = this.permissionAuthorizer.IsAuthorized(permissionSettings.CallContext, permissionSettings.PrivilegesByUserRoom, privilegeId);
if (isAuthorized)
{
return(true);
}
}
return(false);
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app,
IWebHostEnvironment env,
IBackgroundJobClient backgroundJobs,
IServiceProvider serviceProvider,
UserManager <User> userManager)
{
//if (env.IsDevelopment())
//{
// app.UseDeveloperExceptionPage();
//}
app.ConfigureExceptionHandler();
app.UseRouting();
app.UseIdentityServer();
app.UseAuthorization();
app.UseAuthentication();
app.UseCors(AllowSpecificOrigins);
app.UseEndpoints(endpoints =>
{
endpoints.MapControllers().RequireCors(AllowSpecificOrigins);
endpoints.MapHub <IngredientHub>("/ingredients").RequireCors(AllowSpecificOrigins);
});
InitializeContainer();
container.Verify();
RolesSetup.createRoles(serviceProvider).Wait();
PermissionSettings.SeedPermissions(container).Wait();
TablesSettings.SeedTables(container).Wait();
RestaurantDetailsSettings.DetailsSetup(container).Wait();
ConfigureReports.ConfigureReportsDate(container, userManager).Wait();
}
public RestrictedPermission(PermissionSettings values, IEnumerable<IPermissionRule> rules)
{
this.values = values;
this.rules = rules;
}
public static void Add <TType>(PermissionSettings permissionSettings)
{
_permissionSettings.Add(typeof(TType), permissionSettings);
}
private IEnumerator UpgradeBuildingBlocks(BasePlayer player, BuildingGrade.Enum targetGrade, PermissionSettings permS, bool isAdmin)
{
var pay = permS.pay && !permission.UserHasPermission(player.UserIDString, PERMISSION_NO_COST);
int current = 0, success = 0;
var autoGrade = targetGrade == BuildingGrade.Enum.None;
foreach (var buildingBlock in allBuildingBlocks)
{
if (buildingBlock == null || buildingBlock.IsDestroyed)
{
continue;
}
BuildingGrade.Enum grade = targetGrade;
if (CheckBuildingGrade(buildingBlock, true, ref grade))
{
if (!autoGrade || tempGrantedGrades.Contains(grade))
{
if (TryUpgradeToGrade(buildingBlock, player, grade, pay, isAdmin))
{
success++;
}
}
}
if (++current % configData.globalS.perFrame == 0)
{
yield return(CoroutineEx.waitForEndOfFrame);
}
}
foreach (var item in collect)
{
takeOutItems[item.info.itemid] += item.amount;
item.Remove();
}
foreach (var entry in takeOutItems)
{
player.Command("note.inv " + entry.Key + " " + entry.Value * -1f);
}
if (player != null && player.IsConnected)
{
if (missingDictionary.Count > 0)
{
StringBuilder stringBuilder = Pool.Get <StringBuilder>();
var language = lang.GetLanguage(player.UserIDString);
foreach (var entry in missingDictionary)
{
stringBuilder.AppendLine(Lang("MissingItemsFormat", player.UserIDString, GetItemDisplayName(language, entry.Key), entry.Value));
}
var missingResources = stringBuilder.ToString();
stringBuilder.Clear();
Pool.Free(ref stringBuilder);
Print(player, success > 0 ? Lang("UpgradeNotEnoughItemsSuccess", player.UserIDString, success, missingResources) : Lang("UpgradeNotEnoughItems", player.UserIDString, missingResources));
}
else
{
Print(player, success > 0 ? Lang("FinishedUpgrade", player.UserIDString, success) : Lang("NotUpgraded", player.UserIDString));
}
}
collect.Clear();
takeOutItems.Clear();
missingDictionary.Clear();
}
private IEnumerator DowngradeBuildingBlocks(BasePlayer player, BuildingGrade.Enum targetGrade, PermissionSettings permS, bool isAdmin)
{
int current = 0, success = 0;
var autoGrade = targetGrade == BuildingGrade.Enum.None;
foreach (var buildingBlock in allBuildingBlocks)
{
if (buildingBlock == null || buildingBlock.IsDestroyed)
{
continue;
}
BuildingGrade.Enum grade = targetGrade;
if (CheckBuildingGrade(buildingBlock, false, ref grade))
{
if (!autoGrade || tempGrantedGrades.Contains(grade))
{
if (TryDowngradeToGrade(buildingBlock, player, grade /*, permS.refund*/, isAdmin: isAdmin))
{
success++;
}
}
}
if (current++ % configData.globalS.perFrame == 0)
{
yield return(CoroutineEx.waitForEndOfFrame);
}
}
if (player != null && player.IsConnected)
{
Print(player, success > 0 ? Lang("FinishedDowngrade", player.UserIDString, success) : Lang("NotDowngraded", player.UserIDString));
}
}
public void SetUp()
{
this.permissionSettings = new PermissionSettings();
}
public IEnumerator StartChangeBuildingGrade(BuildingBlock sourceEntity, BasePlayer player, BuildingGrade.Enum targetGrade, HashSet <uint> filter, PermissionSettings permS, bool isUpgrade, bool isAll, bool isAdmin)
{
yield return(GetAllBuildingBlocks(sourceEntity, filter, isAll));
//if (pay) {
// FindUpgradeCosts(targetGrade);
// if (!CanAffordUpgrade(player)) {
// Clear();
// yield break;
// }
// PayForUpgrade(costs, player);
//}
Print(player, Lang(isUpgrade ? "StartUpgrade" : "StartDowngrade", player.UserIDString));
var playerID = player.userID;
yield return(isUpgrade ? UpgradeBuildingBlocks(player, targetGrade, permS, isAdmin) : DowngradeBuildingBlocks(player, targetGrade, permS, isAdmin));
tempFriends.Clear();
allBuildingBlocks.Clear();
tempGrantedGrades.Clear();
cooldowns[playerID] = Time.realtimeSinceStartup;
changeGradeCoroutine = null;
}
public bool IsEnabled(PermissionSettings permissionSettings)
{
return(permissionSettings.PropertyStatusTypeId != 5);
}
public bool IsVisible(PermissionSettings permissionSettings)
{
return(true);
}
public bool IsVisible(PermissionSettings permissionSettings)
{
return(!permissionSettings.IsPrivate);
}
public bool IsEnabled(PermissionSettings permissionSettings)
{
return(!permissionSettings.IsPrivate);
}
internal override bool IsVisibleAndEnabled(PermissionSettings permissionSettings)
{
this.IsVisibleAndEnabledCalledTimes++;
return(true);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddHangfire(configuration => configuration
.SetDataCompatibilityLevel(CompatibilityLevel.Version_170)
.UseSimpleAssemblyNameTypeSerializer()
.UseRecommendedSerializerSettings()
.UseSqlServerStorage(Configuration.GetConnectionString("SqlConnection"), new SqlServerStorageOptions
{
CommandBatchMaxTimeout = TimeSpan.FromMinutes(5),
SlidingInvisibilityTimeout = TimeSpan.FromMinutes(5),
QueuePollInterval = TimeSpan.Zero,
UseRecommendedIsolationLevel = true,
DisableGlobalLocks = true
}));
services.AddHangfireServer();
services.AddCors(options =>
{
options.AddPolicy(name: AllowSpecificOrigins, builder =>
{
builder.WithOrigins("http://localhost:3000")
.AllowAnyHeader()
.AllowAnyMethod();
});
});
services.AddSignalR();
services.AddControllers().AddNewtonsoftJson(options =>
options.SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore
);;
services.AddDbContext <ApplicationDbContext>(options =>
options.UseSqlServer(Configuration.GetConnectionString("SqlConnection")));
//Dev db and real db are different Reminder
services.AddScoped <IAuthorizationHandler, PermissionHandler>();
services.AddSimpleInjector(container, options => {
options.AddAspNetCore()
.AddControllerActivation();
});
services.AddIdentity <User, Roles>(options =>
{
options.SignIn.RequireConfirmedAccount = true;
options.Tokens.EmailConfirmationTokenProvider = TokenOptions.DefaultEmailProvider;
}).AddDefaultTokenProviders()
.AddEntityFrameworkStores <ApplicationDbContext>();
services.AddIdentityServer()
.AddJwtBearerClientAuthentication()
.AddAspNetIdentity <User>()
.AddInMemoryApiResources(IdentityServerConfiguration.GetApis())
.AddInMemoryClients(IdentityServerConfiguration.GetClients())
.AddDeveloperSigningCredential();
var JwtSettingsSection = Configuration.GetSection("JwtSettings");
services.Configure <JwtTokenSettings>(JwtSettingsSection);
var JwtTokenSettings = JwtSettingsSection.Get <JwtTokenSettings>();
var key = Encoding.ASCII.GetBytes(JwtTokenSettings.Secret);
services.AddAuthentication(options => {
options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
})
.AddJwtBearer("Bearer", options =>
{
options.RequireHttpsMetadata = false;
options.SaveToken = true;
options.TokenValidationParameters = new Microsoft.IdentityModel.Tokens.TokenValidationParameters()
{
IssuerSigningKey = new SymmetricSecurityKey(key),
ValidIssuer = JwtTokenSettings.Issuer,
ValidAudience = JwtTokenSettings.Audience,
ClockSkew = TimeSpan.Zero
};
options.Events = new JwtBearerEvents
{
OnMessageReceived = context =>
{
var accessToken = context.Request.Query["access_token"];
// If the request is for hub
var path = context.HttpContext.Request.Path;
if (!string.IsNullOrEmpty(accessToken) &&
(path.StartsWithSegments("/ingredients")))
{
// Read the token out of the query string
context.Token = accessToken;
}
return(Task.CompletedTask);
}
};
});
services.AddAuthorization(options =>
options = PermissionSettings.CreatePermissions(options)
);
}
public bool IsVisible(PermissionSettings permissionSettings)
{
return(this.IsVisibleAndEnabled(permissionSettings));
}
