public PDFPermission ReadPDFSecurity(PDFDocument sourcePDF)
{
PDFPermission pDFPermission;
PDFHelper.DisplayTrialPopupIfNecessary();
try
{
PDFPermission pDFPermission1 = null;
AccessPermission currentAccessPermission = sourcePDF.PDFBoxDocument.getCurrentAccessPermission();
if (currentAccessPermission != null)
{
pDFPermission1 = new PDFPermission()
{
AllowAssembly = currentAccessPermission.canAssembleDocument(),
AllowDegradedPrinting = currentAccessPermission.canPrintDegraded(),
AllowExtractContents = currentAccessPermission.canExtractContent(),
AllowExtractForAccessibility = currentAccessPermission.canExtractForAccessibility(),
AllowFillInForm = currentAccessPermission.canFillInForm(),
AllowModifyAnnotations = currentAccessPermission.canModifyAnnotations(),
AllowModifyContents = currentAccessPermission.canModifyAnnotations(),
AllowPrinting = currentAccessPermission.canPrint()
};
}
pDFPermission = pDFPermission1;
}
catch (Exception exception1)
{
Exception exception = exception1;
throw new PDFToolkitException(exception.Message, exception);
}
return(pDFPermission);
}
public override int GetHashCode()
{
return(AppId.GetHashCode() ^ DllSurrogate.GetSafeHashCode()
^ RunAs.GetSafeHashCode() ^ Name.GetSafeHashCode() ^ Flags.GetHashCode() ^
LaunchPermission.GetSafeHashCode() ^ AccessPermission.GetSafeHashCode() ^
LocalService.GetSafeHashCode() ^ RotFlags.GetHashCode());
}
/**
* Creates an new instance of the standard protection policy
* in order to protect a PDF document with passwords.
*
* @param ownerPassword The owner's password.
* @param userPassword The users's password.
* @param permissions The access permissions given to the user.
*/
public StandardProtectionPolicy(string ownerPassword, string userPassword,
AccessPermission permissions)
{
this.ownerPassword = ownerPassword;
this.userPassword = userPassword;
this.permissions = permissions;
}
internal static void Set(ref uint descriptor, AccessPermission ap)
{
DebugStub.Assert(IsType.Get(descriptor, L1.SectionType) ||
IsType.Get(descriptor, L1.SupersectionType));
descriptor = ((descriptor & ~L1.ApMask) | ((uint)ap) << L1.ApRoll);
}
/// <summary>
/// Creates a profile during user creation phase
/// </summary>
/// <param name="email"></param>
private void CreateProfile(string email)
{
//Create and Access Permission
AccessPermission ap = new AccessPermission()
{
PublicAccess = true,
FriendAccess = true,
PublisherAccess = true,
MinorAccess = true
};
db.AccessPermissions.Add(ap);
db.SaveChanges();
//Create new LPProfile object
LPProfile lpProfile = new LPProfile();
//Get LPUser
LPUser lpUser = db.LPUsers.Where(em => em.Email == email).SingleOrDefault();
//Set Profile UserID
lpProfile.UserID = lpUser.UserID;
//Add AcessPermission obj
lpProfile.AccessPermission = ap;
//Add to db
db.LPProfiles.Add(lpProfile);
db.SaveChanges();
//Proceed to next phase
CreateProfileRole(lpUser.UserID);
}
private void UpdateRemoteAccessPermissions(AccessPermission permission)
{
this.endPointLock.EnterReadLock();
this.endPoints.Where(x => x.AccessType == AccessType.Remote)
.ForEach(x => x.SetAccessPermission(permission));
this.endPointLock.ExitReadLock();
}
private Guid RegisterToken(AccessType accessType, AccessPermission permission, Guid?deviceId = null)
{
var token = Guid.NewGuid();
this.endPointLock.EnterWriteLock();
this.endPoints.Add(new AccessEndPoint(token, accessType, permission, deviceId));
this.endPointLock.ExitWriteLock();
return(token);
}
public AccessEndPoint(Guid accessToken, AccessType accessType, AccessPermission accessPermission, Guid?deviceId = null)
{
this.AccessToken = accessToken;
this.AccessType = accessType;
this.accessPermission = new BehaviorSubject <AccessPermission>(accessPermission);
this.DeviceId = deviceId;
this.registeredEntries = new HashSet <PlaylistEntry>();
this.entryCount = new BehaviorSubject <int>(0);
}
private async Task PushAccessPermission(AccessPermission accessPermission)
{
var content = JObject.FromObject(new
{
accessPermission
});
NetworkMessage message = CreatePushMessage(PushAction.UpdateAccessPermission, content);
await this.SendMessage(message);
}
private async Task <ResponseInfo> GetConnectionInfo(JToken parameters)
{
Guid deviceId = Guid.Parse(parameters["deviceId"].ToString());
this.accessToken = this.library.RemoteAccessControl.RegisterRemoteAccessToken(deviceId);
this.Log().Info("Registering new mobile client with access token {0}", this.accessToken);
if (this.library.RemoteAccessControl.IsRemoteAccessReallyLocked)
{
var password = parameters["password"].Value <string>();
if (password != null)
{
try
{
this.library.RemoteAccessControl.UpgradeRemoteAccess(this.accessToken, password);
}
catch (WrongPasswordException)
{
return(CreateResponse(ResponseStatus.WrongPassword));
}
}
}
AccessPermission accessPermission = await this.library.RemoteAccessControl.ObserveAccessPermission(this.accessToken).FirstAsync();
// This is stupid
NetworkAccessPermission permission = accessPermission == AccessPermission.Admin ? NetworkAccessPermission.Admin : NetworkAccessPermission.Guest;
int?remainingVotes = await this.library.RemoteAccessControl.ObserveRemainingVotes(this.accessToken).FirstAsync();
var guestSystemInfo = new GuestSystemInfo
{
IsEnabled = remainingVotes.HasValue,
};
if (remainingVotes.HasValue)
{
guestSystemInfo.RemainingVotes = remainingVotes.Value;
}
var connectionInfo = new ConnectionInfo
{
AccessPermission = permission,
ServerVersion = AppInfo.Version,
GuestSystemInfo = guestSystemInfo
};
this.SetupPushNotifications();
return(CreateResponse(ResponseStatus.Success, null, JObject.FromObject(connectionInfo)));
}
private void RenderPermissions([NotNull] string title, AccessPermission entityPermission, AccessPermission descendantsPermission)
{
Assert.ArgumentNotNull(title, nameof(title));
Writer.WriteStartElement(SecurityStruct.Node.Permission);
Writer.WriteAttributeString(SecurityStruct.Attribute.Title, title);
Writer.WriteAttributeString(SecurityStruct.Attribute.EntityPermission, PermissionToString(entityPermission));
Writer.WriteAttributeString(SecurityStruct.Attribute.DescendantsPermission, PermissionToString(descendantsPermission));
Writer.WriteEndElement();
}
/// <summary>
/// Throws a <see cref="HttpResponseException" /> at run time if the security requirement is not met.
/// </summary>
/// <param name="resource">The <see cref="SharedResourceItem" /> to protect.</param>
/// <param name="requiredPermission">The required permission.</param>
/// <param name="cancellationToken">A token to observe while waiting for the task to complete.</param>
/// <returns>
/// A task that represents the asynchronous operation.
/// </returns>
public static async Task AuthorizeAsync(SharedResourceItem resource, AccessPermission requiredPermission, CancellationToken cancellationToken)
{
if (resource == null)
{
throw new HttpResponseException(HttpStatusCode.Forbidden);
}
var securityResult = await Manager.CheckAccessAsync(resource, WebSecurity.IsAuthenticated?CurrentUserName : null, requiredPermission, cancellationToken);
if (!securityResult.AccessGranted)
{
throw new HttpResponseException(HttpStatusCode.Forbidden);
}
}
private void SetRight(string strDatabase, string strItem, string strAccount, List <AccessRight> rights)
{
//Get Access Rules, Set Access Rules
try
{
Sitecore.Data.Database db = Sitecore.Configuration.Factory.GetDatabase(strDatabase);
Item item = db.GetItem(strItem);
AccountType accountType = AccountType.User;
Account account = Account.FromName(strAccount, accountType);
AccessPermission rightState = AccessPermission.Allow;
if (Sitecore.Security.SecurityUtility.IsRole(strAccount))
{
accountType = Sitecore.Security.Accounts.AccountType.Role;
}
AccessRuleCollection accessRules = item.Security.GetAccessRules();
foreach (AccessRight right in rights)
{
try
{
accessRules.Helper.RemoveExactMatches(account, right);
}
catch (Exception ex)
{
Log.Debug("accessRules.Helper.RemoveExactMatches " + ex.Message.ToString());
}
try
{
accessRules.Helper.AddAccessPermission(account, right, PropagationType.Entity, rightState);
accessRules.Helper.AddAccessPermission(account, right, PropagationType.Descendants, rightState);
Log.Debug(account.Name.ToString() + " has access right of " + right.Name.ToString() + " for " + strItem);
}
catch (Exception ex)
{
Log.Debug("accessRules.Helper.AddAccessPermission " + ex.Message.ToString());
}
}
item.Security.SetAccessRules(accessRules);
}
catch
(Exception ex)
{
Log.Debug(ex.Message.ToString());
}
}
private TreeNode AddNode(TreeNode node, AccessPermission item)
{
TreeNode newnode = new TreeNode(item.AccessPermissionTreeTitle);
newnode.Tag = item;
newnode.Checked = item.Allow;
if (node == null)
{
this.Nodes.Add(newnode);
}
else
{
node.Nodes.Add(newnode);
}
return(newnode);
}
private async Task <ResponseInfo> AddPlaylistSongs(JToken parameters)
{
IEnumerable <Song> songs;
ResponseInfo response;
bool areValid = this.TryValidateSongGuids(parameters["guids"].Select(x => x.ToString()), out songs, out response);
if (areValid)
{
AccessPermission permission = await this.library.RemoteAccessControl.ObserveAccessPermission(this.accessToken).FirstAsync();
if (permission == AccessPermission.Guest)
{
int?remainingVotes = await this.library.RemoteAccessControl.ObserveRemainingVotes(this.accessToken).FirstAsync();
if (remainingVotes == null)
{
return(CreateResponse(ResponseStatus.NotSupported, "Voting isn't supported"));
}
if (remainingVotes == 0)
{
return(CreateResponse(ResponseStatus.Rejected, "Not enough votes left"));
}
}
if (permission == AccessPermission.Admin)
{
this.library.AddSongsToPlaylist(songs, this.accessToken);
}
else
{
if (songs.Count() > 1)
{
return(CreateResponse(ResponseStatus.Unauthorized, "Guests can't add more than one song"));
}
this.library.AddGuestSongToPlaylist(songs.First(), this.accessToken);
}
return(CreateResponse(ResponseStatus.Success));
}
return(response);
}
public string GetUrlWithAccessToken(string path, AccessPermission permission, DateTimeOffset expirationTime)
{
var storageAccount = CloudStorageAccount.Parse(storageOptions.ConnectionString);
var blobClient = storageAccount.CreateCloudBlobClient();
var container = blobClient.GetContainerReference(storageOptions.ImageContainer);
var blob = container.GetBlockBlobReference(path);
var sasPolicy = new SharedAccessBlobPolicy();
sasPolicy.SharedAccessStartTime = DateTime.UtcNow.AddMinutes(-5);
sasPolicy.SharedAccessExpiryTime = expirationTime;
sasPolicy.Permissions = MapFrom(permission);
string sasToken = blob.GetSharedAccessSignature(sasPolicy);
return(blob.Uri + sasToken);
}
public AccessPermission GetAccessPermission(long moduleId)
{
var accessPermission = new AccessPermission();
var userRole = UserRoleDetail.GetAll().Where(u => u.UserId == UserId && u.IsActive).Select(x => x.RoleId).ToArray();
var permRole = RoleDetail.GetAll().Where(r => userRole.Contains(r.RoleId) && r.IsActive && r.ModuleId == moduleId);
//to get highest value from all roles
foreach (var rd in permRole)
{
accessPermission.View = rd.View || accessPermission.View;
accessPermission.Delete = rd.Delete || accessPermission.Delete;
accessPermission.Edit = rd.Edit || accessPermission.Edit;
accessPermission.Add = rd.Add || accessPermission.Add;
}
return(accessPermission);
}
public string GetUrlWithAccessToken(string path, AccessPermission permission, DateTimeOffset expirationTime)
{
var blobServiceClient = new BlobServiceClient(storageOptions.ConnectionString);
var container = blobServiceClient.GetBlobContainerClient(storageOptions.ImageContainer);
var blobClient = container.GetBlobClient(path);
var sasBuilder = new BlobSasBuilder()
{
BlobContainerName = storageOptions.ImageContainer,
BlobName = blobClient.Name,
Resource = "b",
StartsOn = DateTime.UtcNow.AddMinutes(-5),
ExpiresOn = expirationTime
};
sasBuilder.SetPermissions(MapFrom(permission));
var sasUri = blobClient.GenerateSasUri(sasBuilder);
return(sasUri.ToString());
}
private static SharedAccessBlobPermissions MapFrom(AccessPermission permissions)
{
var blobPermissions = SharedAccessBlobPermissions.None;
if ((permissions & AccessPermission.Read) != 0)
{
blobPermissions |= SharedAccessBlobPermissions.Read;
}
if ((permissions & AccessPermission.Write) != 0)
{
blobPermissions |= SharedAccessBlobPermissions.Write;
}
if ((permissions & AccessPermission.Delete) != 0)
{
blobPermissions |= SharedAccessBlobPermissions.Delete;
}
return(blobPermissions);
}
private static BlobSasPermissions MapFrom(AccessPermission permissions)
{
var blobPermissions = BlobSasPermissions.Read;
if ((permissions & AccessPermission.Read) != 0)
{
blobPermissions |= BlobSasPermissions.Read;
}
if ((permissions & AccessPermission.Write) != 0)
{
blobPermissions |= BlobSasPermissions.Write;
}
if ((permissions & AccessPermission.Delete) != 0)
{
blobPermissions |= BlobSasPermissions.Delete;
}
return(blobPermissions);
}
private async Task <ResponseInfo> QueueRemoteSong(JToken parameters)
{
AccessPermission permission = await this.library.RemoteAccessControl.ObserveAccessPermission(this.accessToken).FirstAsync();
if (permission == AccessPermission.Guest)
{
int?remainingVotes = await this.library.RemoteAccessControl.ObserveRemainingVotes(this.accessToken).FirstAsync();
if (remainingVotes == null)
{
return(CreateResponse(ResponseStatus.NotSupported, "Voting isn't supported"));
}
if (remainingVotes == 0)
{
return(CreateResponse(ResponseStatus.Rejected, "Not enough votes left"));
}
}
var transferInfo = parameters.ToObject <SongTransferInfo>();
IObservable <byte[]> data = this.songTransfers.FirstAsync(x => x.TransferId == transferInfo.TransferId).Select(x => x.Data);
var song = MobileSong.Create(transferInfo.Metadata, data);
if (permission == AccessPermission.Guest)
{
this.library.AddGuestSongToPlaylist(song, this.accessToken);
}
else
{
this.library.AddSongsToPlaylist(new[] { song }, this.accessToken);
}
return(CreateResponse(ResponseStatus.Success));
}
public void SecurePDF(PDFDocument sourcePDF, string outputFile)
{
PDFHelper.DisplayTrialPopupIfNecessary();
try
{
AccessPermission accessPermission = new AccessPermission();
accessPermission.setCanAssembleDocument(this.Permission.AllowAssembly);
accessPermission.setCanExtractContent(this.Permission.AllowExtractContents);
accessPermission.setCanExtractForAccessibility(this.Permission.AllowExtractForAccessibility);
accessPermission.setCanFillInForm(this.Permission.AllowFillInForm);
accessPermission.setCanModify(this.Permission.AllowModifyContents);
accessPermission.setCanModifyAnnotations(this.Permission.AllowModifyAnnotations);
accessPermission.setCanPrint(this.Permission.AllowPrinting);
accessPermission.setCanPrintDegraded(this.Permission.AllowDegradedPrinting);
StandardProtectionPolicy standardProtectionPolicy = new StandardProtectionPolicy(this.OwnerPassword, this.UserPassword, accessPermission);
if (!PDFHelper.AddStamp)
{
sourcePDF.PDFBoxDocument.protect(standardProtectionPolicy);
sourcePDF.PDFBoxDocument.save(outputFile);
sourcePDF.PDFBoxDocument.close();
}
else
{
PDDocument pDFBoxDocument = sourcePDF.PDFBoxDocument;
pDFBoxDocument = PDFHelper.AddTrialStampIfNecessary(pDFBoxDocument);
pDFBoxDocument.protect(standardProtectionPolicy);
pDFBoxDocument.save(outputFile);
pDFBoxDocument.close();
}
}
catch (Exception exception1)
{
Exception exception = exception1;
throw new PDFToolkitException(exception.Message, exception);
}
}
private void Submit_Click(object sender, RoutedEventArgs e)
{
try
{
if (this._EditType != 0)
{
RoleData newRole = new RoleData();
if (this._EditType > 1)
{
if (!this._isNewRole)
{
newRole.RoleId = this._RoleData.RoleId;
}
foreach (XamDataTreeNode category in this.AccessTree.Nodes)
{
CategoryNode categoryNode = (CategoryNode)category.Data;
categoryNode.ModuleNodes.Clear();
foreach (XamDataTreeNode module in category.Nodes)
{
ModuleNode moduleNode = (ModuleNode)module.Data;
moduleNode.OperationNodes.Clear();
foreach (XamDataTreeNode operation in module.Nodes)
{
if ((bool)operation.IsChecked)
{
AccessPermission access = new AccessPermission();
access.CategotyType = categoryNode.CategoryType;
access.ModuleType = moduleNode.Type;
OperationNode operationNode = (OperationNode)operation.Data;
access.OperationId = operationNode.Id;
access.OperationName = operationNode.OperationDescription;
newRole.AccessPermissions.Add(access);
}
}
}
}
foreach (XamDataTreeNode systemNode in this.DataTree.Nodes)
{
ExchangeSystemNode system = (ExchangeSystemNode)systemNode.Data;
foreach (XamDataTreeNode typeNode in systemNode.Nodes)
{
DataObjectTypeNode dataType = (DataObjectTypeNode)typeNode.Data;
foreach (XamDataTreeNode dataNode in typeNode.Nodes)
{
if ((bool)dataNode.IsChecked)
{
DataPermission dataPermission = new DataPermission();
dataPermission.ExchangeSystemCode = system.ExChangeCode;
dataPermission.DataObjectType = dataType.Type;
DataObjectNode data = (DataObjectNode)dataNode.Data;
dataPermission.DataObjectId = data.DataObjectId;
dataPermission.DataObjectDescription = data.Decription;
newRole.DataPermissions.Add(dataPermission);
}
}
}
}
}
if (this._EditType % 2 == 1)
{
newRole.RoleName = this.RoleName.Text;
}
this._RoleData = newRole;
if (CheckNewRole(newRole))
{
ConsoleClient.Instance.UpdateRole(newRole, this._isNewRole, EditResult);
}
}
}
catch (Exception ex)
{
Logger.TraceEvent(System.Diagnostics.TraceEventType.Error, "Submit_Click.\r\n{0}", ex.ToString());
}
//ConsoleClient.Instance.UpdateRolePermission(this._roleId, this._EditType, this.RoleName.Text, this._NewAccessTree, this._NewDataTree, EditResult);
}
public void SetAccessPermission(AccessPermission permission)
{
this.accessPermission.OnNext(permission);
}
public void Execute(AccessPermission accessPermission, int numberIfacade)
{
// var periodCatalog = new PermissionCatalog(typeof(IPeriodServiceFacade));
// periodCatalog.AddPermission(new Permission("AddPeriod", new List<ActionType>() {ActionType.AddPeriod}));
// periodCatalog.AddPermission(new Permission("UpdatePeriod", new List<ActionType>() {ActionType.ModifyPeriod}));
// periodCatalog.AddPermission(new Permission("DeletePeriod", new List<ActionType>() {ActionType.DeletePeriod}));
// periodCatalog.AddPermission(new Permission("ChangePeriodState", new List<ActionType>() {
// ActionType.ActivatePeriod,
// ActionType.InitializePeriodForInquiry,
// ActionType.StartInquiry,
// ActionType.CompleteInquiry,
// ActionType.ClosePeriod}));
// accessPermission.AddCatalog(periodCatalog);
// var periodUnitCatalog = new PermissionCatalog(typeof(IPeriodUnitServiceFacade));
// periodCatalog.AddPermission(new Permission("GetUnitsWithActions", new List<ActionType>() {ActionType.ManageUnits}));
// periodCatalog.AddPermission(new Permission("AssignUnit", new List<ActionType>() {ActionType.AddUnitInPeriod}));
// periodCatalog.AddPermission(new Permission("RemoveUnit", new List<ActionType>() {ActionType.DeleteUnitInPeriod}));
// accessPermission.AddCatalog(periodUnitCatalog);
// var periodJobPositionCatalog = new PermissionCatalog(typeof(IPeriodJobPositionServiceFacade));
// periodJobPositionCatalog.AddPermission(new Permission("GetJobPositionsWithActions", new List<ActionType>() {ActionType.ManageJobPositions}));
// periodJobPositionCatalog.AddPermission(new Permission("AssignJobPosition", new List<ActionType>() {ActionType.AddJobPositionInPeriod}));
// periodJobPositionCatalog.AddPermission(new Permission("RemoveJobPosition", new List<ActionType>() {ActionType.DeleteJobPositionInPeriod}));
// periodJobPositionCatalog.AddPermission(new Permission("GetInquirySubjectsWithInquirers", new List<ActionType>() {ActionType.ManageJobPositionInPeriodInquiry}));
// periodJobPositionCatalog.AddPermission(new Permission("UpdateInquirySubjectInquirers", new List<ActionType>(){ActionType.ManageJobPositionInPeriodInquiry}));
// accessPermission.AddCatalog(periodJobPositionCatalog);
// var periodJobIndexCatalog = new PermissionCatalog(typeof(IPeriodJobIndexServiceFacade));
// periodJobIndexCatalog.AddPermission(new Permission("GetAllAbstractJobIndices", new List<ActionType>() {ActionType.ManageJobIndices}));
// periodJobIndexCatalog.AddPermission(new Permission("AddJobIndex", new List<ActionType>() {ActionType.AddJobIndexInPeriod}));
// periodJobIndexCatalog.AddPermission(new Permission("UpdateJobIndex", new List<ActionType>() {ActionType.ModifyJobIndexInPeriod}));
// periodJobIndexCatalog.AddPermission(new Permission("DeleteAbstractJobIndex", new List<ActionType>() {ActionType.DeleteJobIndexInPeriod, ActionType.DeleteJobIndexGroupInPeriod}));
// periodJobIndexCatalog.AddPermission(new Permission("AddJobIndexGroup", new List<ActionType>() {ActionType.AddJobIndexGroupInPeriod}));
// periodJobIndexCatalog.AddPermission(new Permission("UpdateJobIndexGroup", new List<ActionType>() {ActionType.ModifyJobIndexGroupInPeriod}));
// accessPermission.AddCatalog(periodJobIndexCatalog);
//var periodJobCatalog = new PermissionCatalog(typeof(IPeriodJobServiceFacade));
// periodJobCatalog.AddPermission(new Permission("GetAllJobs", new List<ActionType>() {ActionType.ManageJobInPeriod}));
// periodJobCatalog.AddPermission(new Permission("AssignJob", new List<ActionType>() {ActionType.AddJobInPeriod}));
// periodJobCatalog.AddPermission(new Permission("UpdateJob", new List<ActionType>() {ActionType.ModifyJobInPeriod}));
// periodJobCatalog.AddPermission(new Permission("RemoveJob", new List<ActionType>() {ActionType.DeleteJobInPeriod}));
//accessPermission.AddCatalog(periodJobCatalog);
//var calculationCatalog = new PermissionCatalog(typeof(ICalculationServiceFacade));
// calculationCatalog.AddPermission(new Permission("GetAllCalculations", new List<ActionType>() {ActionType.ManageCalculations}));
// calculationCatalog.AddPermission(new Permission("AddCalculation", new List<ActionType>() {ActionType.AddCalculation}));
// calculationCatalog.AddPermission(new Permission("DeleteCalculation", new List<ActionType>() {ActionType.DeleteCalculation}));
// calculationCatalog.AddPermission(new Permission("ChangeCalculationState", new List<ActionType>() {
// ActionType.ModifyCalculation,
// ActionType.RunCalculation,
// ActionType.StopCalculation,
// ActionType.SetDeterministicCalculation}));
//accessPermission.AddCatalog(calculationCatalog);
//var employeeCatalog = new PermissionCatalog(typeof(IEmployeeServiceFacade));
// employeeCatalog.AddPermission(new Permission("GetAllEmployees", new List<ActionType>() {ActionType.ManageEmployees}));
// employeeCatalog.AddPermission(new Permission("AddEmployee", new List<ActionType>() {ActionType.AddEmployee}));
// employeeCatalog.AddPermission(new Permission("UpdateEmployee", new List<ActionType>() {ActionType.ModifyEmployee}));
// employeeCatalog.AddPermission(new Permission("DeleteEmployee", new List<ActionType>() {ActionType.DeleteEmployee}));
// employeeCatalog.AddPermission(new Permission("AssignJobPositionsToEmployee", new List<ActionType>() {ActionType.ManageEmployeeJobPositions}));
//accessPermission.AddCatalog(employeeCatalog);
//var jobIndexCatalog = new PermissionCatalog(typeof(IJobIndexFacadeService));
// jobIndexCatalog.AddPermission(new Permission("AddJobIndex", new List<ActionType>() {ActionType.AddJobIndex}));
// jobIndexCatalog.AddPermission(new Permission("UpdateJobIndex", new List<ActionType>() {ActionType.ModifyJobIndex, ActionType.ManageJobIndexCustomFields}));
// jobIndexCatalog.AddPermission(new Permission("DeleteAbstractJobIndex", new List<ActionType>() {ActionType.DeleteJobIndexCategory}));
// jobIndexCatalog.AddPermission(new Permission("AddJobIndexCategory", new List<ActionType>() {ActionType.AddJobIndexCategory}));
// jobIndexCatalog.AddPermission(new Permission("UpdateJobIndexCategory", new List<ActionType>() {ActionType.ModifyJobIndexCategory}));
// accessPermission.AddCatalog(jobIndexCatalog);
// var jobPositionCatalog = new PermissionCatalog(typeof(IJobPositionFacadeService));
// jobPositionCatalog.AddPermission(new Permission("AddJobPosition", new List<ActionType>() {ActionType.AddJobPosition}));
// jobPositionCatalog.AddPermission(new Permission("DeleteJob", new List<ActionType>() {ActionType.DeleteJobPosition}));
// jobPositionCatalog.AddPermission(new Permission("UpdateJobPosition", new List<ActionType>() {ActionType.ModifyJobPosition}));
// accessPermission.AddCatalog(jobPositionCatalog);
// var functionCatalog = new PermissionCatalog(typeof(IFunctionFacadeService));
// functionCatalog.AddPermission(new Permission("AddFunction", new List<ActionType>() {ActionType.CreateFunction}));
// functionCatalog.AddPermission(new Permission("DeleteFunction", new List<ActionType>() {ActionType.DeleteFunction}));
// functionCatalog.AddPermission(new Permission("UpdateFunction", new List<ActionType>() {ActionType.ModifyFunction}));
// functionCatalog.AddPermission(new Permission("GetPolicyFunctionsWithPagination", new List<ActionType>() {ActionType.ManageFunctions}));
// accessPermission.AddCatalog(functionCatalog);
// var customFieldCatalog = new PermissionCatalog(typeof(ICustomFieldFacadeService));
// customFieldCatalog.AddPermission(new Permission("AddCustomField", new List<ActionType>() {ActionType.CreateCustomField}));
// customFieldCatalog.AddPermission(new Permission("DeleteCustomeField", new List<ActionType>() {ActionType.DeleteCustomField}));
// customFieldCatalog.AddPermission(new Permission("UpdateCustomField", new List<ActionType>() {ActionType.ModifyCustomField}));
// accessPermission.AddCatalog(customFieldCatalog);
// var jobCatalog = new PermissionCatalog(typeof(IJobFacadeService));
// jobCatalog.AddPermission(new Permission("AddJob", new List<ActionType>() {ActionType.CreateJob}));
// jobCatalog.AddPermission(new Permission("DeleteJob", new List<ActionType>() {ActionType.DeleteJob}));
// jobCatalog.AddPermission(new Permission("UpdateJob", new List<ActionType>() {ActionType.ModifyJob, ActionType.ModifyJobCustomFields}));
// accessPermission.AddCatalog(jobCatalog);
// var unitCatalog = new PermissionCatalog(typeof(IUnitFacadeService));
// unitCatalog.AddPermission(new Permission("AddUnit", new List<ActionType>() {ActionType.AddUnit}));
// unitCatalog.AddPermission(new Permission("DeleteUnit", new List<ActionType>() {ActionType.DeleteUnit}));
// unitCatalog.AddPermission(new Permission("UpdateUnit", new List<ActionType>() {ActionType.ModifyUnit}));
// accessPermission.AddCatalog(unitCatalog);
// var policyCatalog = new PermissionCatalog(typeof(IPolicyFacadeService));
// policyCatalog.AddPermission(new Permission("AddPolicy", new List<ActionType>() {ActionType.AddPolicy}));
// policyCatalog.AddPermission(new Permission("DeletePolicy", new List<ActionType>() {ActionType.DeletePolicy}));
// policyCatalog.AddPermission(new Permission("UpdatePolicy", new List<ActionType>() {ActionType.ModifyPolicy}));
// accessPermission.AddCatalog(policyCatalog);
// var ruleCatalog = new PermissionCatalog(typeof(IRuleFacadeService));
// ruleCatalog.AddPermission(new Permission("GetPolicyRulesWithPagination", new List<ActionType>() {ActionType.ManageRules}));
// ruleCatalog.AddPermission(new Permission("AddRule", new List<ActionType>() {ActionType.AddRule}));
// ruleCatalog.AddPermission(new Permission("DeleteRule", new List<ActionType>() {ActionType.DeleteRule}));
// ruleCatalog.AddPermission(new Permission("UpdateRule", new List<ActionType>() {ActionType.ModifyRule}));
// accessPermission.AddCatalog(ruleCatalog);
// var jobIndexPointCatalog = new PermissionCatalog(typeof(IJobIndexPointFacadeService));
// jobIndexPointCatalog.AddPermission(new Permission("GetAllJobIndexPoints", new List<ActionType>() {ActionType.ShowCalculationResult}));
// accessPermission.AddCatalog(jobIndexPointCatalog);
// var inquiryCatalog = new PermissionCatalog(typeof(IInquiryServiceFacade));
// inquiryCatalog.AddPermission(new Permission("GetInquiryForm", new List<ActionType>() {ActionType.FillInquiryForm}));
// inquiryCatalog.AddPermission(new Permission("UpdateInquirySubjectForm", new List<ActionType>() {ActionType.FillInquiryForm}));
// accessPermission.AddCatalog(inquiryCatalog);
// var periodClaimCatalog = new PermissionCatalog(typeof(IPeriodClaimServiceFacade));
// periodClaimCatalog.AddPermission(new Permission("AddClaim", new List<ActionType>() {ActionType.AddClaim}));
// periodClaimCatalog.AddPermission(new Permission("GetClaim", new List<ActionType>() {ActionType.ShowClaim}));
// periodClaimCatalog.AddPermission(new Permission("ChangeClaimState", new List<ActionType>() {ActionType.ReplyToClaim}));
// periodClaimCatalog.AddPermission(new Permission("DeleteClaim", new List<ActionType>() {ActionType.DeleteClaim}));
// periodClaimCatalog.AddPermission(new Permission("GetAllClaimsForAdminWithActions", new List<ActionType>() {ActionType.ShowAdminClaimList}));
// accessPermission.AddCatalog(periodClaimCatalog);
if (numberIfacade != accessPermission.CatalogCount)
{
throw new SecurityException("Count Of Catalog not valid");
}
}
private static string PermissionToString(AccessPermission permission)
{
return(permission == AccessPermission.Allow ? @"+" : (permission == AccessPermission.Deny ? @"-" : @"x"));
}
private string GetAccessPermission(AccessRuleCollection rules, Sitecore.Security.Accounts.Account account, AccessRight accessRight, AccessPermission accessPermission, string sExistingPermissions)
{
if ((rules.Helper.GetAccessPermission(account, accessRight, PropagationType.Descendants) == accessPermission) &&
(sExistingPermissions.IndexOf(accessRight.Name) == -1))
{
sExistingPermissions += accessRight.Name + "|";
}
return sExistingPermissions;
}
private async Task PushAccessPermission(AccessPermission accessPermission)
{
var content = JObject.FromObject(new
{
accessPermission
});
NetworkMessage message = CreatePushMessage(PushAction.UpdateAccessPermission, content);
await this.SendMessage(message);
}
public void SetRight(string strDatabase, string strItem, string strAccount, string strRights, AccessPermission rightState, PropagationType propagationType, Credentials credentials)
{
this.Invoke("SetRight", new object[] {
strDatabase,
strItem,
strAccount,
strRights,
rightState,
propagationType,
credentials
});
}
private string GetAccessPermission(AccessRuleCollection rules, Sitecore.Security.Accounts.Account account, AccessRight accessRight, AccessPermission accessPermission, string sExistingPermissions)
{
if ((rules.Helper.GetAccessPermission(account, accessRight, PropagationType.Descendants) == accessPermission) &&
(sExistingPermissions.IndexOf(accessRight.Name) == -1))
{
sExistingPermissions += accessRight.Name + "|";
}
return(sExistingPermissions);
}
/// <remarks/>
public void SetRightAsync(string strDatabase, string strItem, string strAccount, string strRights, AccessPermission rightState, PropagationType propagationType, Credentials credentials)
{
this.SetRightAsync(strDatabase, strItem, strAccount, strRights, rightState, propagationType, credentials, null);
}
/// <remarks/>
public void SetRightAsync(string strDatabase, string strItem, string strAccount, string strRights, AccessPermission rightState, PropagationType propagationType, Credentials credentials, object userState)
{
if ((this.SetRightOperationCompleted == null))
{
this.SetRightOperationCompleted = new System.Threading.SendOrPostCallback(this.OnSetRightOperationCompleted);
}
this.InvokeAsync("SetRight", new object[] {
strDatabase,
strItem,
strAccount,
strRights,
rightState,
propagationType,
credentials
}, this.SetRightOperationCompleted, userState);
}
public void SetRight(string strDatabase, string strItem, string strAccount, string strRights, AccessPermission rightState, PropagationType propagationType, Credentials credentials) {
this.Invoke("SetRight", new object[] {
strDatabase,
strItem,
strAccount,
strRights,
rightState,
propagationType,
credentials});
}
/// <remarks/>
public void SetRightAsync(string strDatabase, string strItem, string strAccount, string strRights, AccessPermission rightState, PropagationType propagationType, Credentials credentials) {
this.SetRightAsync(strDatabase, strItem, strAccount, strRights, rightState, propagationType, credentials, null);
}
public async Task <ResponseViewModel> Register(RegisterVM model)
{
try
{
ApplicationUser existuser = null;
using (AuthRepository _repo = new AuthRepository())
{
existuser = (ApplicationUser)_repo.GetUser(model.UserName).Content;
}
if (existuser != null)
{
if (!string.IsNullOrEmpty(existuser.Id))
{
registrationresponseModel.IsSuccess = false;
registrationresponseModel.IsMap = false;
registrationresponseModel.Message = "User already exist.";
}
}
else
{
var user = new ApplicationUser()
{
UserName = model.UserName, Email = model.Email
};
user.LockoutEnabled = false;
//user.LockoutEndDateUtc = DateTime.UtcNow.AddMinutes(3);
var result = await UserManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
IHttpActionResult rslt = GetErrorResult(result);
}
else
{
// Generate Token for Email Confirmation...
var code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
var tokencode = HttpUtility.UrlEncode(code);
//Add Contact Details
Contact contct = new Contact()
{
FirstName = model.FirstName,
LastName = model.LastName,
Email = model.Email,
Address = model.Address,
Gender = model.Gender,
City = model.City,
ContactNo = model.ContactNo,
Designation = model.Designation,
UserId = user.Id
};
contactRepository.Add(contct);
_unitOfWork.Commit();
// Add NetUserDetails
UserTypeMapping userTypeMapping = new UserTypeMapping()
{
UserId = user.Id,
ContactId = contct.Id,
UserType = model.Designation
};
userTypeMappingRepository.Add(userTypeMapping);
if (!string.IsNullOrEmpty(model.ManagerId) && !string.IsNullOrEmpty(user.Id))
{
ManagerSupervisorTypeMapping mgrsprmapp = new ManagerSupervisorTypeMapping()
{
SupervisorId = user.Id,
ManagerId = model.ManagerId
};
managerSupervisorTypeRepository.Add(mgrsprmapp);
_unitOfWork.Commit();
}
// Add Permissions
AccessPermission accessPermission = new AccessPermission()
{
UserId = user.Id,
ContactId = contct.Id,
UserType = model.Designation,
// IsMaterialReports = true,
// IsWorkReports = true
};
if (model.Designation == (long)UserType.Manager)
{
accessPermission.IsMaterialReports = true;
accessPermission.IsMaterialInward = true;
accessPermission.IsMaterialOutward = true;
accessPermission.IsWorkReports = true;
// accessPermission.IsWorkComplete = true;
//accessPermission.IsWorkGenrate = true;
}
else if (model.Designation == (long)UserType.Supervisor)
{
accessPermission.IsWorkComplete = true;
accessPermission.IsWorkGenrate = true;
accessPermission.IsWorkReports = true;
}
else if (model.Designation == (long)UserType.Engineer)
{
accessPermission.IsWorkReports = true;
}
accessPermissionRepository.Add(accessPermission);
_unitOfWork.Commit();
}
registrationresponseModel.IsSuccess = true;
registrationresponseModel.Message = "User Registered Successfully.";
return(registrationresponseModel);
}
}
catch (Exception ex)
{
}
return(registrationresponseModel);
}
/// <remarks/>
public void SetRightAsync(string strDatabase, string strItem, string strAccount, string strRights, AccessPermission rightState, PropagationType propagationType, Credentials credentials, object userState) {
if ((this.SetRightOperationCompleted == null)) {
this.SetRightOperationCompleted = new System.Threading.SendOrPostCallback(this.OnSetRightOperationCompleted);
}
this.InvokeAsync("SetRight", new object[] {
strDatabase,
strItem,
strAccount,
strRights,
rightState,
propagationType,
credentials}, this.SetRightOperationCompleted, userState);
}
