public RoleManager(IRoleData roleData, IStringLocalizer <RoleManager> localizer, ILogger <RoleManager> logger, IKeyManager keyManager)
{
_roleData = roleData;
_localizer = localizer;
_logger = logger;
_keyManager = keyManager;
}
public virtual void WriteSerializedRole(IRoleData roleData, Stream outputStream)
{
Assert.ArgumentNotNull(roleData, nameof(roleData));
Assert.ArgumentNotNull(outputStream, "outputStream");
var memberOfRoles = roleData.MemberOfRoles;
using (var writer = new YamlWriter(outputStream, 4096, true))
{
writer.WriteMap("Role", roleData.RoleName);
if (memberOfRoles.Any())
{
writer.WriteMap("MemberOf");
writer.IncreaseIndent();
foreach (var memberOfRole in memberOfRoles)
{
writer.WriteMap("Role", memberOfRole);
}
writer.DecreaseIndent();
}
}
}
protected virtual void SetRoleData()
{
if (mRole != default)
{
mRoleData = mRole.RoleDataSource;
}
}
public PredicateResult Includes(IRoleData role)
{
Assert.ArgumentNotNull(role, nameof(role));
// no entries = include everything
if (_includeEntries.Count == 0)
{
return(new PredicateResult(true));
}
var result = new PredicateResult(true);
PredicateResult priorityResult = null;
foreach (var entry in _includeEntries)
{
result = Includes(entry, role);
if (result.IsIncluded)
{
return(result); // it's definitely included if anything includes it
}
if (!string.IsNullOrEmpty(result.Justification))
{
priorityResult = result; // a justification means this is probably a more 'important' fail than others
}
}
return(priorityResult ?? result); // return the last failure
}
public virtual void WriteSerializedRole(IRoleData roleData, Stream outputStream)
{
Assert.ArgumentNotNull(roleData, nameof(roleData));
Assert.ArgumentNotNull(outputStream, "outputStream");
var memberOfRoles = roleData.MemberOfRoles;
using (var writer = new YamlWriter(outputStream, 4096, true))
{
writer.WriteMap("Role", roleData.RoleName);
if (memberOfRoles.Any())
{
writer.WriteMap("MemberOf");
writer.IncreaseIndent();
foreach (var memberOfRole in memberOfRoles)
{
writer.WriteMap("Role", memberOfRole);
}
writer.DecreaseIndent();
}
}
}
public UserData(
IRepository repository,
IRoleData roleData,
IPermissionData permissionData) : base(repository)
{
this.roleData = roleData;
this.permissionData = permissionData;
}
public RoleController(RoleManager <ApplicationRole> roleManager,
IRoleData roleData,
IApiErrorHandler apiErrorHandler)
{
_roleManager = roleManager;
_roleData = roleData;
_apiErrorHandler = apiErrorHandler;
}
protected virtual void DeserializeRole(IRoleData role)
{
bool addedRole = false;
// Add role if needed
var name = role.RoleName;
if (!System.Web.Security.Roles.RoleExists(name))
{
_loaderLogger.AddedNewRole(role);
addedRole = true;
System.Web.Security.Roles.CreateRole(name);
}
Role targetRole = Role.FromName(name);
var currentSourceParents = new SitecoreRoleData(targetRole).MemberOfRoles;
var currentTargetParents = role.MemberOfRoles;
var addedRoleMembership = new List <string>();
var removedRoleMembership = new List <string>();
var deferredUpdateLog = new DeferredLogWriter <IRoleLoaderLogger>();
// Loop over the serialized parent roles and set db roles if needed
foreach (var serializedMemberRoleName in currentTargetParents)
{
var memberRole = Role.FromName(serializedMemberRoleName);
// add nonexistant parent role if needed. NOTE: parent role need not be one we have serialized or included.
if (!Role.Exists(serializedMemberRoleName))
{
deferredUpdateLog.AddEntry(log => log.AddedNewRoleMembership(new SitecoreRoleData(memberRole)));
System.Web.Security.Roles.CreateRole(serializedMemberRoleName);
}
// Add membership if not already in the parent role
if (!RolesInRolesManager.IsRoleInRole(targetRole, memberRole, false))
{
addedRoleMembership.Add(memberRole.Name);
RolesInRolesManager.AddRoleToRole(targetRole, memberRole);
}
}
// Loop over parent roles that exist in the database but not in serialized and remove them
var membershipToRemove = currentSourceParents.Where(parent => !currentTargetParents.Contains(parent, StringComparer.OrdinalIgnoreCase));
foreach (var roleToRemove in membershipToRemove)
{
removedRoleMembership.Add(roleToRemove);
RolesInRolesManager.RemoveRoleFromRole(targetRole, Role.FromName(roleToRemove));
}
if (!addedRole && (addedRoleMembership.Count > 0 || removedRoleMembership.Count > 0))
{
_loaderLogger.RoleMembershipChanged(role, addedRoleMembership.ToArray(), removedRoleMembership.ToArray());
}
deferredUpdateLog.ExecuteDeferredActions(_loaderLogger);
}
public ApiManager(IApiData apiData, IStringLocalizer <IApiManager> localizer, ILogger <IApiManager> logger,
IKeyManager keyManager, IRoleData roleData)
{
_apiData = apiData;
_localizer = localizer;
_logger = logger;
_keyManager = keyManager;
_roleData = roleData;
}
public virtual void Remove(IRoleData role)
{
var path = GetPathForRole(role);
if (File.Exists(path))
{
File.Delete(path);
}
}
public UserRoleBusiness(
IUserRoleData data,
IUserData userData,
IRoleData roleData)
{
this.data = data;
this.userData = userData;
this.roleData = roleData;
}
public RolePermissionBusiness(
IRolePermissionData data,
IRoleData roleData,
IPermissionData permissionData)
{
this.data = data;
this.roleData = roleData;
this.permissionData = permissionData;
}
protected virtual void DeserializeRole(IRoleData role)
{
bool addedRole = false;
// Add role if needed
var name = role.RoleName;
if (!System.Web.Security.Roles.RoleExists(name))
{
_loaderLogger.AddedNewRole(role);
addedRole = true;
System.Web.Security.Roles.CreateRole(name);
}
Role targetRole = Role.FromName(name);
var currentSourceParents = new SitecoreRoleData(targetRole).MemberOfRoles;
var currentTargetParents = role.MemberOfRoles;
var addedRoleMembership = new List<string>();
var removedRoleMembership = new List<string>();
var deferredUpdateLog = new DeferredLogWriter<IRoleLoaderLogger>();
// Loop over the serialized parent roles and set db roles if needed
foreach (var serializedMemberRoleName in currentTargetParents)
{
var memberRole = Role.FromName(serializedMemberRoleName);
// add nonexistant parent role if needed. NOTE: parent role need not be one we have serialized or included.
if (!Role.Exists(serializedMemberRoleName))
{
deferredUpdateLog.AddEntry(log => log.AddedNewRoleMembership(new SitecoreRoleData(memberRole)));
System.Web.Security.Roles.CreateRole(serializedMemberRoleName);
}
// Add membership if not already in the parent role
if (!RolesInRolesManager.IsRoleInRole(targetRole, memberRole, false))
{
addedRoleMembership.Add(memberRole.Name);
RolesInRolesManager.AddRoleToRole(targetRole, memberRole);
}
}
// Loop over parent roles that exist in the database but not in serialized and remove them
var membershipToRemove = currentSourceParents.Where(parent => !currentTargetParents.Contains(parent, StringComparer.OrdinalIgnoreCase));
foreach (var roleToRemove in membershipToRemove)
{
removedRoleMembership.Add(roleToRemove);
RolesInRolesManager.RemoveRoleFromRole(targetRole, Role.FromName(roleToRemove));
}
if (!addedRole && (addedRoleMembership.Count > 0 || removedRoleMembership.Count > 0))
{
_loaderLogger.RoleMembershipChanged(role, addedRoleMembership.ToArray(), removedRoleMembership.ToArray());
}
deferredUpdateLog.ExecuteDeferredActions(_loaderLogger);
}
public virtual void RoleMembershipChanged(IRoleData role, string[] updatedRoleMembership, string[] removedRoleMembership)
{
_baseLogger.Info($"[U] Role {role.RoleName}");
foreach (var addedRole in updatedRoleMembership)
{
_baseLogger.Debug($"* [A] Added membership in {addedRole}");
}
foreach (var removedRole in removedRoleMembership)
{
_baseLogger.Debug($"* [D] Removed membership in {removedRole}");
}
}
public virtual void RoleMembershipChanged(IRoleData role, string[] updatedRoleMembership, string[] removedRoleMembership)
{
_baseLogger.Info($"[U] Role {role.RoleName}");
foreach (var addedRole in updatedRoleMembership)
{
_baseLogger.Debug($"* [A] Added membership in {addedRole}");
}
foreach (var removedRole in removedRoleMembership)
{
_baseLogger.Debug($"* [D] Removed membership in {removedRole}");
}
}
public KeyManager(IKeyData keyData,
IStringLocalizer <IKeyManager> localizer,
ILogger <IKeyManager> logger,
IRoleData roleData,
KeySecretCache keySecretCache)
{
_keyData = keyData;
_localizer = localizer;
_logger = logger;
_roleData = roleData;
_keySecretCache = keySecretCache;
}
public virtual void Save(IRoleData role)
{
var path = GetPathForRole(role);
var parent = Path.GetDirectoryName(path);
if (!Directory.Exists(parent)) Directory.CreateDirectory(parent);
using (var writer = File.Open(path, FileMode.Create, FileAccess.Write, FileShare.None))
{
_formatter.WriteSerializedRole(role, writer);
}
}
private void RoleAmoutExtranTurn()
{
if (mRole == default || mRoleInput == default)
{
return;
}
mRoleData = mRole.RoleDataSource;
Vector3 move = Vector3.ProjectOnPlane(mRoleInput.GetMoveValue(), mRole.GroundNormal);
mRoleInput.SetMoveValue(move);
mRoleInput.UpdateAmout(RoleEntitas);
mRoleInput.UpdateRoleExtraTurnRotation(ref mRoleData);
}
public RoleData() : base()
{
if (isMultiDatabase)
{
base.Init(this.GetType().FullName, System.Reflection.Assembly.GetExecutingAssembly().GetName().Name, dicmultiDatabase[this.GetType().Name].ToString());
}
else
{
base.Init(this.GetType().FullName, System.Reflection.Assembly.GetExecutingAssembly().GetName().Name);
}
baseDal.OnOperationLog += new OperationLogEventHandler(OperationLog.OnOperationLog);//如果需要记录操作日志，则实现这个事件
dal = baseDal as IRoleData;
}
/// <summary>
/// Checks if a preset includes a given item
/// </summary>
protected PredicateResult Includes(ConfigurationRolePredicateEntry entry, IRoleData role)
{
var split = role.RoleName.Split('\\');
var domain = split[0];
var roleName = split.Last();
// domain match
if(!string.IsNullOrWhiteSpace(entry.Domain) && !domain.Equals(entry.Domain, StringComparison.OrdinalIgnoreCase)) return new PredicateResult(false);
// pattern match
if(!string.IsNullOrWhiteSpace(entry.Pattern) && !Regex.IsMatch(roleName, entry.Pattern, RegexOptions.IgnoreCase | RegexOptions.Compiled)) return new PredicateResult(false);
// pattern is either null or white space, or it matches
return new PredicateResult(true);
}
public UserService(IUserData userData,
IRoleData roleData,
IUserRoleData userRoleData,
IUserRefreshTokenData userRefreshTokenData,
IOptions <AuthenticationSettings> authenticationSettings,
IMapper mapper,
IEmailSender emailSender)
{
this._userData = userData;
this._roleData = roleData;
this._userRoleData = userRoleData;
this._userRefreshTokenData = userRefreshTokenData;
this._authenticationSettings = authenticationSettings.Value;
this._mapper = mapper;
this._emailSender = emailSender;
}
public virtual void Save(IRoleData role)
{
var path = GetPathForRole(role);
var parent = Path.GetDirectoryName(path);
if (!Directory.Exists(parent))
{
Directory.CreateDirectory(parent);
}
using (var writer = File.Open(path, FileMode.Create, FileAccess.Write, FileShare.None))
{
_formatter.WriteSerializedRole(role, writer);
}
}
public EmployeeType(IRoleData _roleData)
{
Field(_ => _.Id);
Field(_ => _.Username);
Field(_ => _.FirstName);
Field(_ => _.LastName);
Field(_ => _.Nif);
Field(_ => _.Birthdate);
Field(_ => _.Adress);
Field(_ => _.Phone);
Field(_ => _.Email);
Field(_ => _.HashedPassword);
Field(_ => _.CreatedAt);
Field(_ => _.RoleId);
Field <RoleType>(
"role",
resolve: context => _roleData.GetAsync(context.Source.RoleId));
}
public override void Execute(int time, ref IShipDockEntitas target)
{
base.Execute(time, ref target);
mRoleItem = target as ICommonRole;
if (mRoleItem == default)
{
return;
}
mRoleData = mRoleItem.RoleDataSource;
mRoleInput = mRoleItem.RoleInput;
mAnimatorInfo = mRoleItem.RoleAnimatorInfo;
if (mRoleItem.IsUserControlling && (mRoleInput != default) && mRoleInput.ShouldGetUserInput)
{
CheckUserInput();
mRoleInput.ShouldGetUserInput = false;
}
}
public PredicateResult Includes(IRoleData role)
{
Assert.ArgumentNotNull(role, nameof(role));
// no entries = include everything
if (_includeEntries.Count == 0) return new PredicateResult(true);
var result = new PredicateResult(true);
PredicateResult priorityResult = null;
foreach (var entry in _includeEntries)
{
result = Includes(entry, role);
if (result.IsIncluded) return result; // it's definitely included if anything includes it
if (!string.IsNullOrEmpty(result.Justification)) priorityResult = result; // a justification means this is probably a more 'important' fail than others
}
return priorityResult ?? result; // return the last failure
}
public string GenerateAddRoleStatements(IRoleData role)
{
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.AppendLine("DECLARE @applicationId nvarchar(256)");
stringBuilder.AppendLine("SELECT TOP 1 @applicationId = [ApplicationId] FROM [aspnet_Applications] WHERE [ApplicationName] = 'sitecore'");
stringBuilder.AppendLine(string.Concat("IF NOT EXISTS (SELECT TOP 1 [RoleId] FROM [aspnet_Roles] WHERE [ApplicationId] = @applicationId AND [RoleName] = '", role.RoleName, "')"));
stringBuilder.AppendLine("BEGIN");
stringBuilder.AppendLine(" INSERT INTO [aspnet_Roles] (ApplicationId, RoleId, RoleName, LoweredRoleName, Description)");
stringBuilder.AppendLine(string.Concat(new string[] { " VALUES (@applicationId, NEWID(), '", role.RoleName, "', LOWER('", role.RoleName, "'), NULL)" }));
stringBuilder.AppendLine("END");
foreach (string membership in role.MemberOfRoles)
{
stringBuilder.AppendLine(string.Concat(new string[] { "IF NOT EXISTS (SELECT TOP 1 * FROM [RolesInRoles] WHERE [MemberRoleName] = '", role.RoleName, "' AND [TargetRoleName] = '", membership, "')" }));
stringBuilder.AppendLine("BEGIN");
stringBuilder.AppendLine(" INSERT INTO [RolesInRoles] (Id, MemberRoleName, TargetRoleName, ApplicationName, Created)");
stringBuilder.AppendLine(string.Concat(new string[] { " VALUES (NEWID(), '", role.RoleName, "', '", membership, "', '', SYSUTCDATETIME())" }));
stringBuilder.AppendLine("END");
}
stringBuilder.AppendLine("GO");
return(stringBuilder.ToString());
}
/// <summary>
/// Checks if a preset includes a given item
/// </summary>
protected PredicateResult Includes(ConfigurationRolePredicateEntry entry, IRoleData role)
{
var split = role.RoleName.Split('\\');
var domain = split[0];
var roleName = split.Last();
// domain match
if (!string.IsNullOrWhiteSpace(entry.Domain) && !domain.Equals(entry.Domain, StringComparison.OrdinalIgnoreCase))
{
return(new PredicateResult(false));
}
// pattern match
if (!string.IsNullOrWhiteSpace(entry.Pattern) && !Regex.IsMatch(roleName, entry.Pattern, RegexOptions.IgnoreCase | RegexOptions.Compiled))
{
return(new PredicateResult(false));
}
// pattern is either null or white space, or it matches
return(new PredicateResult(true));
}
public virtual void AddedNewRole(IRoleData role)
{
_baseLogger.Info($"[A] Role {role.RoleName}");
}
protected virtual string GetPathForRole(IRoleData role)
{
return(Path.Combine(_physicalRootPath, role.RoleName + _formatter.FileExtension));
}
public RoleController(IRoleData roleData)
{
_roleData = roleData;
}
protected virtual void EvaluateOrphans(IRoleData[] roles)
{
var knownRoles = roles.ToLookup(key => key.RoleName);
var allOrphanRoles = RolesInRolesManager.GetAllRoles(false)
.Select(role => new SitecoreRoleData(role))
.Where(role => _rolePredicate.Includes(role).IsIncluded)
.Where(role => !knownRoles.Contains(role.RoleName))
.ToArray();
foreach (var orphan in allOrphanRoles)
{
_loaderLogger.RemovedOrphanRole(orphan);
System.Web.Security.Roles.DeleteRole(orphan.RoleName);
}
}
public virtual void Remove(IRoleData role)
{
var path = GetPathForRole(role);
if (File.Exists(path)) File.Delete(path);
}
protected virtual string GetPathForRole(IRoleData role)
{
return Path.Combine(_physicalRootPath, role.RoleName + _formatter.FileExtension);
}
public virtual void AddedNewRole(IRoleData role)
{
_baseLogger.Info($"[A] Role {role.RoleName}");
}
public virtual void RemovedOrphanRole(IRoleData orphan)
{
_baseLogger.Warn($"[D] Deleted role {orphan.RoleName} because it was not in the serialization store. If deleted by mistake, you can recreate the role by name to restore it.");
}
public RoleBusiness(IRoleData data) => this.data = data;
// public RootMutation(IWineData wineData)
// {
// Field<WineType>(
// "addWine",
// arguments: new QueryArguments
// {
// new QueryArgument<InputWineType>(){ Name = "wine"}
// },
// resolve: context =>
// {
// var wine = context.GetArgument<Wine>("wine");
// wineData.AddWine(wine);
// return null;
// }
// );
// }
public RootMutation(IEmployeeData employeeData,
IRoleData roleData,
IPermissionData permissionData,
ITaskData taskData,
ICategoryData categoryData,
IStockData stockData,
IStepData stepData,
IWineData wineData,
IProductData productData,
IStockProductData stockProductData,
IStockWineData stockWineData)
{
// EMPLOYEE
Field <EmployeeType>(
"addEmployee",
arguments: new QueryArguments
{
new QueryArgument <InputEmployeeType>()
{
Name = "employee"
}
},
resolve: context =>
{
var employee = context.GetArgument <Employee>("employee");
return(employeeData.AddEmployee(employee));
}
);
Field <EmployeeType>(
"updateEmployee",
arguments: new QueryArguments {
new QueryArgument <InputEmployeeType>()
{
Name = "employee"
}
},
resolve: context =>
{
var employee = context.GetArgument <Employee>("employee");
return(employeeData.Update(employee));
}
);
Field <EmployeeType>(
"deleteEmployee",
arguments: new QueryArguments {
new QueryArgument <InputEmployeeType>()
{
Name = "employee"
}
},
resolve: context =>
{
var employee = context.GetArgument <Employee>("employee");
employeeData.Delete(employee);
return(employee);
}
);
// ROLE
Field <RoleType>(
"addRole",
arguments: new QueryArguments
{
new QueryArgument <InputRoleType>()
{
Name = "role"
}
},
resolve: context =>
{
var role = context.GetArgument <Role>("role");
return(roleData.AddRole(role));
}
);
Field <RoleType>(
"updateRole",
arguments: new QueryArguments {
new QueryArgument <InputRoleType>()
{
Name = "role"
}
},
resolve: context =>
{
var role = context.GetArgument <Role>("role");
return(roleData.Update(role));
}
);
Field <RoleType>(
"deleteRole",
arguments: new QueryArguments {
new QueryArgument <InputRoleType>()
{
Name = "role"
}
},
resolve: context =>
{
var role = context.GetArgument <Role>("role");
roleData.Delete(role);
return(role);
}
);
// PERMISSION
Field <PermissionType>(
"addPermission",
arguments: new QueryArguments
{
new QueryArgument <InputPermissionType>()
{
Name = "permission"
}
},
resolve: context =>
{
var permission = context.GetArgument <Permission>("permission");
return(permissionData.AddPermission(permission));
}
);
Field <PermissionType>(
"updatePermission",
arguments: new QueryArguments {
new QueryArgument <InputPermissionType>()
{
Name = "permission"
}
},
resolve: context =>
{
var permission = context.GetArgument <Permission>("permission");
return(permissionData.Update(permission));
}
);
Field <PermissionType>(
"deletePermission",
arguments: new QueryArguments {
new QueryArgument <InputPermissionType>()
{
Name = "permission"
}
},
resolve: context =>
{
var permission = context.GetArgument <Permission>("permission");
permissionData.Delete(permission);
return(permission);
}
);
// TASK
Field <TaskType>(
"addTask",
arguments: new QueryArguments
{
new QueryArgument <InputTaskType>()
{
Name = "task"
}
},
resolve: context =>
{
var task = context.GetArgument <Task>("task");
return(taskData.AddTask(task));
}
);
Field <TaskType>(
"updateTask",
arguments: new QueryArguments {
new QueryArgument <InputTaskType>()
{
Name = "task"
}
},
resolve: context =>
{
var task = context.GetArgument <Task>("task");
return(taskData.Update(task));
}
);
Field <TaskType>(
"deleteTask",
arguments: new QueryArguments {
new QueryArgument <InputTaskType>()
{
Name = "task"
}
},
resolve: context =>
{
var task = context.GetArgument <Task>("task");
taskData.Delete(task);
return(task);
}
);
// CATEGORY
Field <CategoryType>(
"addCategory",
arguments: new QueryArguments
{
new QueryArgument <InputCategoryType>()
{
Name = "category"
}
},
resolve: context =>
{
var category = context.GetArgument <Category>("category");
return(categoryData.AddCategory(category));
}
);
Field <CategoryType>(
"updateCategory",
arguments: new QueryArguments {
new QueryArgument <InputCategoryType>()
{
Name = "category"
}
},
resolve: context =>
{
var category = context.GetArgument <Category>("category");
return(categoryData.Update(category));
}
);
Field <CategoryType>(
"deleteCategory",
arguments: new QueryArguments {
new QueryArgument <InputCategoryType>()
{
Name = "category"
}
},
resolve: context =>
{
var category = context.GetArgument <Category>("category");
categoryData.Delete(category);
return(category);
}
);
// STOCK
Field <StockType>(
"addStock",
arguments: new QueryArguments
{
new QueryArgument <InputStockType>()
{
Name = "stock"
}
},
resolve: context =>
{
var stock = context.GetArgument <Stock>("stock");
return(stockData.AddStock(stock));
}
);
Field <StockType>(
"updateStock",
arguments: new QueryArguments {
new QueryArgument <InputStockType>()
{
Name = "stock"
}
},
resolve: context =>
{
var stock = context.GetArgument <Stock>("stock");
return(stockData.Update(stock));
}
);
Field <StockType>(
"deleteStock",
arguments: new QueryArguments {
new QueryArgument <InputStockType>()
{
Name = "stock"
}
},
resolve: context =>
{
var stock = context.GetArgument <Stock>("stock");
stockData.Delete(stock);
return(stock);
}
);
// STEP
Field <StepType>(
"addStep",
arguments: new QueryArguments
{
new QueryArgument <InputStepType>()
{
Name = "step"
}
},
resolve: context =>
{
var step = context.GetArgument <Step>("step");
return(stepData.AddStep(step));
}
);
Field <StepType>(
"updateStep",
arguments: new QueryArguments {
new QueryArgument <InputStepType>()
{
Name = "step"
}
},
resolve: context =>
{
var step = context.GetArgument <Step>("step");
return(stepData.Update(step));
}
);
Field <StepType>(
"deleteStep",
arguments: new QueryArguments {
new QueryArgument <InputStepType>()
{
Name = "step"
}
},
resolve: context =>
{
var step = context.GetArgument <Step>("step");
stepData.Delete(step);
return(step);
}
);
// WINE
Field <WineType>(
"addWine",
arguments: new QueryArguments
{
new QueryArgument <InputWineType>()
{
Name = "wine"
}
},
resolve: context =>
{
var wine = context.GetArgument <Wine>("wine");
return(wineData.AddWine(wine));
}
);
Field <WineType>(
"updateWine",
arguments: new QueryArguments {
new QueryArgument <InputWineType>()
{
Name = "wine"
}
},
resolve: context =>
{
var wine = context.GetArgument <Wine>("wine");
return(wineData.Update(wine));
}
);
Field <WineType>(
"deleteWine",
arguments: new QueryArguments {
new QueryArgument <InputWineType>()
{
Name = "wine"
}
},
resolve: context =>
{
var wine = context.GetArgument <Wine>("wine");
wineData.Delete(wine);
return(wine);
}
);
// PRODUCT
Field <ProductType>(
"addProduct",
arguments: new QueryArguments
{
new QueryArgument <InputProductType>()
{
Name = "product"
}
},
resolve: context =>
{
var product = context.GetArgument <Product>("product");
return(productData.AddProduct(product));
}
);
Field <ProductType>(
"updateProduct",
arguments: new QueryArguments {
new QueryArgument <InputProductType>()
{
Name = "product"
}
},
resolve: context =>
{
var product = context.GetArgument <Product>("product");
return(productData.Update(product));
}
);
Field <ProductType>(
"deleteProduct",
arguments: new QueryArguments {
new QueryArgument <InputProductType>()
{
Name = "product"
}
},
resolve: context =>
{
var product = context.GetArgument <Product>("product");
productData.Delete(product);
return(product);
}
);
// StockProduct
Field <StockProductType>(
"addStockProduct",
arguments: new QueryArguments
{
new QueryArgument <InputStockProductType>()
{
Name = "stockProduct"
}
},
resolve: context =>
{
var stockProduct = context.GetArgument <StockProduct>("stockProduct");
return(stockProductData.AddStockProduct(stockProduct));
}
);
Field <StockProductType>(
"updateStockProduct",
arguments: new QueryArguments {
new QueryArgument <InputStockProductType>()
{
Name = "stockProduct"
}
},
resolve: context =>
{
var stockProduct = context.GetArgument <StockProduct>("stockProduct");
return(stockProductData.Update(stockProduct));
}
);
Field <StockProductType>(
"deleteStockProduct",
arguments: new QueryArguments {
new QueryArgument <InputStockProductType>()
{
Name = "stockProduct"
}
},
resolve: context =>
{
var stockProduct = context.GetArgument <StockProduct>("stockProduct");
stockProductData.Delete(stockProduct);
return(stockProduct);
}
);
// StockWine
Field <StockWineType>(
"addStockWine",
arguments: new QueryArguments
{
new QueryArgument <InputStockWineType>()
{
Name = "stockWine"
}
},
resolve: context =>
{
var stockWine = context.GetArgument <StockWine>("stockWine");
return(stockWineData.AddStockWine(stockWine));
}
);
Field <StockWineType>(
"updateStockWine",
arguments: new QueryArguments {
new QueryArgument <InputStockWineType>()
{
Name = "stockWine"
}
},
resolve: context =>
{
var stockWine = context.GetArgument <StockWine>("stockWine");
return(stockWineData.Update(stockWine));
}
);
Field <StockWineType>(
"deleteStockWine",
arguments: new QueryArguments {
new QueryArgument <InputStockWineType>()
{
Name = "stockWine"
}
},
resolve: context =>
{
var stockWine = context.GetArgument <StockWine>("stockWine");
stockWineData.Delete(stockWine);
return(stockWine);
}
);
}
public RootQuery(IEmployeeData _employeeData,
IRoleData _roleData,
IPermissionData _permissionData,
ITaskData _taskData,
ICategoryData _categoryData,
IStockData _stockData,
IStepData _stepData,
IWineData _wineData,
IProductData _productData)
{
//EMPLOYEES
Field <ListGraphType <EmployeeType> >("employees", resolve: context =>
{
return(_employeeData.GetAllAsync());
});
Field <EmployeeType>("employee",
arguments: new QueryArguments
{
new QueryArgument <IntGraphType> {
Name = "id"
}
},
resolve: context =>
{
int id = context.GetArgument <int>("id");
return(_employeeData.GetAsync(id));
});
Field <EmployeeType>("employeeEmail",
arguments: new QueryArguments
{
new QueryArgument <StringGraphType> {
Name = "email"
},
new QueryArgument <StringGraphType> {
Name = "password"
}
},
resolve: context =>
{
string email = context.GetArgument <string>("email");
string password = context.GetArgument <string>("password");
return(_employeeData.GetByEmailPasswordAsync(email, password));
});
//ROLES
Field <ListGraphType <RoleType> >("roles", resolve: context =>
{
return(_roleData.GetAllAsync());
});
Field <RoleType>("role",
arguments: new QueryArguments
{
new QueryArgument <IntGraphType> {
Name = "id"
}
},
resolve: context =>
{
int id = context.GetArgument <int>("id");
return(_roleData.GetAsync(id));
});
//PERMISSIONS
Field <ListGraphType <PermissionType> >("permissions", resolve: context =>
{
return(_permissionData.GetAllAsync());
});
Field <PermissionType>("permission",
arguments: new QueryArguments
{
new QueryArgument <IntGraphType> {
Name = "id"
}
},
resolve: context =>
{
int id = context.GetArgument <int>("id");
return(_permissionData.GetAsync(id));
});
// TASKS
Field <ListGraphType <TaskType> >("tasks", resolve: context =>
{
return(_taskData.GetAllAsync());
});
Field <TaskType>("task",
arguments: new QueryArguments
{
new QueryArgument <IntGraphType> {
Name = "id"
}
},
resolve: context =>
{
int id = context.GetArgument <int>("id");
return(_taskData.GetAsync(id));
});
// CATEGORIES
Field <ListGraphType <CategoryType> >("categories", resolve: context =>
{
return(_categoryData.GetAllAsync());
});
Field <CategoryType>("category",
arguments: new QueryArguments
{
new QueryArgument <IntGraphType> {
Name = "id"
}
},
resolve: context =>
{
int id = context.GetArgument <int>("id");
return(_categoryData.GetAsync(id));
});
// STOCKS
Field <ListGraphType <StockType> >("stocks", resolve: context =>
{
return(_stockData.GetAllAsync());
});
Field <StockType>("stock",
arguments: new QueryArguments
{
new QueryArgument <IntGraphType> {
Name = "id"
}
},
resolve: context =>
{
// try{
int id = context.GetArgument <int>("id");
Console.WriteLine("entrou");
return(_stockData.GetAsync(id));
// } catch (Exception error) {
// Console.WriteLine(error);
// return null;
// }
});
// STEPS
Field <ListGraphType <StepType> >("steps", resolve: context =>
{
return(_stepData.GetAllAsync());
});
Field <StepType>("step",
arguments: new QueryArguments
{
new QueryArgument <IntGraphType> {
Name = "id"
}
},
resolve: context =>
{
int id = context.GetArgument <int>("id");
return(_stepData.GetAsync(id));
});
// WINES
Field <ListGraphType <WineType> >("wines", resolve: context =>
{
return(_wineData.GetAllAsync());
});
Field <WineType>("wine",
arguments: new QueryArguments
{
new QueryArgument <IntGraphType> {
Name = "id"
}
},
resolve: context =>
{
int id = context.GetArgument <int>("id");
return(_wineData.GetAsync(id));
});
// PRODUCTS
Field <ListGraphType <ProductType> >("products", resolve: context =>
{
return(_productData.GetAllAsync());
});
Field <ProductType>("product",
arguments: new QueryArguments
{
new QueryArgument <IntGraphType> {
Name = "id"
}
},
resolve: context =>
{
int id = context.GetArgument <int>("id");
return(_productData.GetAsync(id));
});
}
public RoleBusiness(IRoleData roleDataService)
{
_roleDataService = roleDataService;
}
public virtual void RemovedOrphanRole(IRoleData orphan)
{
_baseLogger.Warn($"[D] Deleted role {orphan.RoleName} because it was not in the serialization store. If deleted by mistake, you can recreate the role by name to restore it.");
}
public virtual void AddedNewRoleMembership(IRoleData role)
{
_baseLogger.Info($"> [A] Nonexistent parent role {role.RoleName}");
}
public virtual void AddedNewRoleMembership(IRoleData role)
{
_baseLogger.Info($"> [A] Nonexistent parent role {role.RoleName}");
}
