public bool CheckAccess(string userName, IntPtr userToken, byte[] secDesc, CatalogOperation[] requiredOperations)
{
//Check Overrides
if (IsSecurityOverride(userName))
{
return(true);
}
//Check ACL Permissions
List <CatalogOperation> aggregatePermssions = new List <CatalogOperation>();
AceCollection acl = DeserializeAcl(secDesc);
foreach (AceStruct ace in acl)
{
if (ValidateACLPrincipal(ace.PrincipalName, userName))
{
foreach (CatalogOperation aclOperation in ace.CatalogOperations)
{
aggregatePermssions.Add(aclOperation);
}
}
}
return(!requiredOperations.Except(aggregatePermssions).Any());
}
public bool CheckAccess(string userName, IntPtr userToken, byte[] secDesc, ReportOperation requiredOperation)
{
//Check Overrides
if (IsSecurityOverride(userName))
{
return(true);
}
//Check ACL Permissions
AceCollection acl = DeserializeAcl(secDesc);
foreach (AceStruct ace in acl)
{
if (ValidateACLPrincipal(ace.PrincipalName, userName))
{
foreach (ReportOperation aclOperation in ace.ReportOperations)
{
if (aclOperation == requiredOperation)
{
return(true);
}
}
}
}
return(false);
}
public static Uri ShareFileAndGetUri(string fileId)
{
var file = GetFile(fileId);
var objectId = "file_" + file.ID;
var sharedInfo = Global.FileStorageService.GetSharedInfo(new ItemList <string> {
objectId
}).Find(r => r.SubjectId == FileConstant.ShareLinkId);
if (sharedInfo == null || sharedInfo.Share == FileShare.Restrict || sharedInfo.Share == FileShare.None)
{
var list = new ItemList <AceWrapper>
{
new AceWrapper
{
SubjectId = FileConstant.ShareLinkId,
SubjectGroup = true,
Share = FileShare.Read
}
};
var aceCollection = new AceCollection
{
Entries = new ItemList <string> {
objectId
},
Aces = list
};
Global.FileStorageService.SetAceObject(aceCollection, false);
}
var uri = new Uri(GetUriString(file));
return(uri);
}
public string GenerateSharedLink(string fileid, FileShare share)
{
var file = GetFileInfo(fileid);
var objectid = "file_" + file.Id;
var sharedInfo = _fileStorageService.GetSharedInfo(new Web.Files.Services.WCFService.ItemList <string> {
objectid
}).Find(r => r.SubjectId == FileConstant.ShareLinkId);
if (sharedInfo == null || sharedInfo.Share != share)
{
var list = new Web.Files.Services.WCFService.ItemList <AceWrapper>
{
new AceWrapper
{
SubjectId = FileConstant.ShareLinkId,
SubjectGroup = true,
Share = share
}
};
var aceCollection = new AceCollection
{
Entries = new Web.Files.Services.WCFService.ItemList <string> {
objectid
},
Aces = list
};
_fileStorageService.SetAceObject(aceCollection, false);
sharedInfo = _fileStorageService.GetSharedInfo(new Web.Files.Services.WCFService.ItemList <string> {
objectid
}).Find(r => r.SubjectId == FileConstant.ShareLinkId);
}
return(sharedInfo.SubjectName);
}
// Overload for Datasource operations
public bool CheckAccess(
string userName,
IntPtr userToken,
byte[] secDesc,
DatasourceOperation requiredOperation)
{
// If the user is the administrator, allow unrestricted access.
if (0 == String.Compare(userName, m_adminUserName, true,
CultureInfo.CurrentCulture))
{
return(true);
}
AceCollection acl = DeserializeAcl(secDesc);
foreach (AceStruct ace in acl)
{
if (0 == String.Compare(userName, ace.PrincipalName, true,
CultureInfo.CurrentCulture))
{
foreach (DatasourceOperation aclOperation in
ace.DatasourceOperations)
{
if (aclOperation == requiredOperation)
{
return(true);
}
}
}
}
return(false);
}
// Overload for Datasource operations
public bool CheckAccess(
string userName,
IntPtr userToken,
byte[] secDesc,
DatasourceOperation requiredOperation)
{
// If the user is the administrator, allow unrestricted access.
if (HasUnRestrictedAccess(userName))
{
return(true);
}
AceCollection acl = DeserializeAcl(secDesc);
foreach (AceStruct ace in acl)
{
if (UserMatchesPrincipal(ace.PrincipalName, userToken))
{
foreach (DatasourceOperation aclOperation in
ace.DatasourceOperations)
{
if (aclOperation == requiredOperation)
{
return(true);
}
}
}
}
return(false);
}
public bool CheckAccess(string userName, IntPtr userToken, byte[] secDesc, ModelOperation modelOperation)
{
// If the user is the administrator, allow unrestricted access.
// Because SQL Server defaults to case-insensitive, we have to
// perform a case insensitive comparison. Ideally you would check
// the SQL Server instance CaseSensitivity property before making
// a case-insensitive comparison.
if (0 == String.Compare(userName, m_adminUserName, true, CultureInfo.CurrentCulture))
{
return(true);
}
AceCollection acl = DeserializeAcl(secDesc);
foreach (AceStruct ace in acl)
{
// First check to see if the user or group has an access control
// entry for the item
if (0 == String.Compare(userName, ace.PrincipalName, true, CultureInfo.CurrentCulture))
{
// If an entry is found,
// return true if the given required operation
// is contained in the ACE structure
foreach (ModelOperation aclOperation in ace.ModelOperations)
{
if (aclOperation == modelOperation)
{
return(true);
}
}
}
}
return(false);
}
// Overload for Resource operations
public bool CheckAccess(
string userName,
IntPtr userToken,
byte[] secDesc,
ResourceOperation requiredOperation)
{
// If the user is not report viewer username, allow unrestricted access.
if (!userName.Equals(m_reportViewerUserName))
{
return(true);
}
AceCollection acl = DeserializeAcl(secDesc);
foreach (AceStruct ace in acl)
{
if (0 == String.Compare(userName, ace.PrincipalName, true,
CultureInfo.CurrentCulture))
{
foreach (ResourceOperation aclOperation in
ace.ResourceOperations)
{
if (aclOperation == requiredOperation)
{
return(true);
}
}
}
}
return(false);
}
public byte[] CreateSecurityDescriptor(AceCollection acl, SecurityItemType itemType, out string stringSecDesc)
{
BinaryFormatter binaryFormatter = new BinaryFormatter();
MemoryStream result = new MemoryStream();
binaryFormatter.Serialize(result, acl);
stringSecDesc = null;
return(result.GetBuffer());
}
public byte[] CreateSecurityDescriptor(
AceCollection acl,
SecurityItemType itemType,
out string stringSecDesc)
{
stringSecDesc = null;
EventLog.WriteEntry("SSRS-AZ", "CreateSecurityDescriptor", EventLogEntryType.Information);
return(null);
}
public byte[] CreateSecurityDescriptor(AceCollection acl, SecurityItemType itemType, out string stringSecDesc)
{
// Creates a memory stream and serializes the ACL for storage.
BinaryFormatter bf = new BinaryFormatter();
using (MemoryStream result = new MemoryStream()) {
bf.Serialize(result, acl);
stringSecDesc = null;
return(result.GetBuffer());
}
}
private AceCollection DeserializeAcl(byte[] secDesc)
{
AceCollection acl = new AceCollection();
if (secDesc != null)
{
BinaryFormatter bf = new BinaryFormatter();
using (MemoryStream sdStream = new MemoryStream(secDesc)) {
acl = (AceCollection)bf.Deserialize(sdStream);
}
}
return(acl);
}
private AceCollection DeserializeAcl(byte[] secDesc)
{
var accessControls = new AceCollection();
if (secDesc != null)
{
var binaryFormatter = new BinaryFormatter();
using (var securityDescriptorStream = new MemoryStream(secDesc))
{
accessControls = (AceCollection)binaryFormatter.Deserialize(securityDescriptorStream);
}
}
return(accessControls);
}
public IEnumerable <FileShareWrapper> SetSecurityInfo(IEnumerable <T> fileIds, IEnumerable <T> folderIds, IEnumerable <FileShareParams> share, bool notify, string sharingMessage)
{
if (share != null && share.Any())
{
var list = new List <AceWrapper>(share.Select(FileShareParamsHelper.ToAceObject));
var aceCollection = new AceCollection <T>
{
Files = fileIds,
Folders = folderIds,
Aces = list,
Message = sharingMessage
};
FileStorageService.SetAceObject(aceCollection, notify);
}
return(GetSecurityInfo(fileIds, folderIds));
}
public IEnumerable <FileShareWrapper> SetFileSecurityInfo(string fileid, IEnumerable <FileShareParams> share, bool notify, string sharingMessage)
{
if (share != null && share.Any())
{
var list = new Web.Files.Services.WCFService.ItemList <AceWrapper>(share.Select(x => x.ToAceObject()));
var aceCollection = new AceCollection
{
Entries = new Web.Files.Services.WCFService.ItemList <string> {
"file_" + fileid
},
Aces = list,
Message = sharingMessage
};
_fileStorageService.SetAceObject(aceCollection, notify);
}
return(GetFileSecurityInfo(fileid));
}
public IEnumerable <FileShareWrapper> SetFolderSecurityInfo(T folderId, IEnumerable <FileShareParams> share, bool notify, string sharingMessage)
{
if (share != null && share.Any())
{
var list = new ItemList <AceWrapper>(share.Select(FileShareParamsHelper.ToAceObject));
var aceCollection = new AceCollection
{
Entries = new ItemList <string> {
"folder_" + folderId
},
Aces = list,
Message = sharingMessage
};
FileStorageService.SetAceObject(aceCollection, notify);
}
return(GetFolderSecurityInfo(folderId));
}
public byte[] CreateSecurityDescriptor(
AceCollection acl,
SecurityItemType itemType,
out string stringSecDesc)
{
stringSecDesc = null;
return(null);
}
public string GenerateSharedLink(T fileId, FileShare share)
{
var file = GetFileInfo(fileId);
var sharedInfo = FileStorageService.GetSharedInfo(new List <T> {
fileId
}, new List <T> {
}).Find(r => r.SubjectId == FileConstant.ShareLinkId);
if (sharedInfo == null || sharedInfo.Share != share)
{
var list = new List <AceWrapper>
{
new AceWrapper
{
SubjectId = FileConstant.ShareLinkId,
SubjectGroup = true,
Share = share
}
};
var aceCollection = new AceCollection <T>
{
Files = new List <T> {
fileId
},
Aces = list
};
FileStorageService.SetAceObject(aceCollection, false);
sharedInfo = FileStorageService.GetSharedInfo(new List <T> {
fileId
}, new List <T> {
}).Find(r => r.SubjectId == FileConstant.ShareLinkId);
}
return(sharedInfo.Link);
}
public bool CheckAccess(
string userName,
IntPtr userToken,
byte[] secDesc,
ModelItemOperation modelItemOperation)
{
// If the user is not report viewer username, allow unrestricted access.
if (!userName.Equals(m_reportViewerUserName))
{
return(true);
}
AceCollection acl = DeserializeAcl(secDesc);
foreach (AceStruct ace in acl)
{
// First check to see if the user or group has an access control
// entry for the item
if (0 == String.Compare(userName, ace.PrincipalName, true,
CultureInfo.CurrentCulture))
{
// If an entry is found,
// return true if the given required operation
// is contained in the ACE structure
foreach (ModelItemOperation aclOperation in ace.ModelItemOperations)
{
if (aclOperation == modelItemOperation)
{
return(true);
}
}
}
}
return(false);
}
public static void ChangeAttachedFileLinksAddresses(this MailDraftData draft, ILog log = null)
{
if (log == null)
{
log = new NullLog();
}
var doc = new HtmlDocument();
doc.LoadHtml(draft.HtmlBody);
var linkNodes = doc.DocumentNode.SelectNodes("//a[contains(@class,'mailmessage-filelink-link')]");
if (linkNodes == null)
{
return;
}
var fileStorageService = new FileStorageServiceController();
var setLinks = new List <Tuple <string, string> >();
foreach (var linkNode in linkNodes)
{
var fileId = linkNode.Attributes["data-fileid"].Value;
var objectId = "file_" + fileId;
linkNode.Attributes["class"].Remove(); // 'mailmessage-filelink-link'
linkNode.Attributes["data-fileid"].Remove(); // 'data-fileid'
var setLink = setLinks.SingleOrDefault(x => x.Item1 == fileId);
if (setLink != null)
{
linkNode.SetAttributeValue("href", setLink.Item2);
log.InfoFormat("ChangeAttachedFileLinks() Change file link href: {0}", fileId);
continue;
}
var aceCollection = new AceCollection
{
Entries = new ItemList <string> {
objectId
},
Aces = new ItemList <AceWrapper>
{
new AceWrapper
{
SubjectId = FileConstant.ShareLinkId,
SubjectGroup = true,
Share = draft.FileLinksShareMode
}
}
};
fileStorageService.SetAceObject(aceCollection, false);
log.InfoFormat("ChangeAttachedFileLinks() Set public accees to file: {0}", fileId);
var sharedInfo =
fileStorageService.GetSharedInfo(new ItemList <string> {
objectId
})
.Find(r => r.SubjectId == FileConstant.ShareLinkId);
linkNode.SetAttributeValue("href", sharedInfo.Link);
log.InfoFormat("ChangeAttachedFileLinks() Change file link href: {0}", fileId);
setLinks.Add(new Tuple <string, string>(fileId, sharedInfo.Link));
}
linkNodes = doc.DocumentNode.SelectNodes("//div[contains(@class,'mailmessage-filelink')]");
foreach (var linkNode in linkNodes)
{
linkNode.Attributes["class"].Remove();
}
draft.HtmlBody = doc.DocumentNode.OuterHtml;
}
public byte[] CreateSecurityDescriptor(
AceCollection acl,
SecurityItemType itemType,
out string stringSecDesc)
{
stringSecDesc = null;
return null;
}
public StringCollection GetPermissions(string userName, IntPtr userToken, SecurityItemType itemType, byte[] secDesc)
{
StringCollection permissions = new StringCollection();
if (HasUnRestrictedAccess(userName))
{
foreach (CatalogOperation oper in m_CatOperNames.Keys)
{
if (!permissions.Contains((string)m_CatOperNames[oper]))
{
permissions.Add((string)m_CatOperNames[oper]);
}
}
foreach (ModelItemOperation oper in m_ModelItemOperNames.Keys)
{
if (!permissions.Contains((string)m_ModelItemOperNames[oper]))
{
permissions.Add((string)m_ModelItemOperNames[oper]);
}
}
foreach (ModelOperation oper in m_ModelOperNames.Keys)
{
if (!permissions.Contains((string)m_ModelOperNames[oper]))
{
permissions.Add((string)m_ModelOperNames[oper]);
}
}
foreach (CatalogOperation oper in m_CatOperNames.Keys)
{
if (!permissions.Contains((string)m_CatOperNames[oper]))
{
permissions.Add((string)m_CatOperNames[oper]);
}
}
foreach (ReportOperation oper in m_RptOperNames.Keys)
{
if (!permissions.Contains((string)m_RptOperNames[oper]))
{
permissions.Add((string)m_RptOperNames[oper]);
}
}
foreach (FolderOperation oper in m_FldOperNames.Keys)
{
if (!permissions.Contains((string)m_FldOperNames[oper]))
{
permissions.Add((string)m_FldOperNames[oper]);
}
}
foreach (ResourceOperation oper in m_ResOperNames.Keys)
{
if (!permissions.Contains((string)m_ResOperNames[oper]))
{
permissions.Add((string)m_ResOperNames[oper]);
}
}
foreach (DatasourceOperation oper in m_DSOperNames.Keys)
{
if (!permissions.Contains((string)m_DSOperNames[oper]))
{
permissions.Add((string)m_DSOperNames[oper]);
}
}
}
else
{
AceCollection acl = DeserializeAcl(secDesc);
foreach (AceStruct ace in acl)
{
if (UserMatchesPrincipal(ace.PrincipalName, userToken))
{
foreach (ModelItemOperation aclOperation in ace.ModelItemOperations)
{
if (!permissions.Contains((string)m_ModelItemOperNames[aclOperation]))
{
permissions.Add((string)m_ModelItemOperNames[aclOperation]);
}
}
foreach (ModelOperation aclOperation in ace.ModelOperations)
{
if (!permissions.Contains((string)m_ModelOperNames[aclOperation]))
{
permissions.Add((string)m_ModelOperNames[aclOperation]);
}
}
foreach (CatalogOperation aclOperation in
ace.CatalogOperations)
{
if (!permissions.Contains((string)m_CatOperNames[aclOperation]))
{
permissions.Add((string)m_CatOperNames[aclOperation]);
}
}
foreach (ReportOperation aclOperation in ace.ReportOperations)
{
if (!permissions.Contains((string)m_RptOperNames[aclOperation]))
{
permissions.Add((string)m_RptOperNames[aclOperation]);
}
}
foreach (FolderOperation aclOperation in ace.FolderOperations)
{
if (!permissions.Contains((string)m_FldOperNames[aclOperation]))
{
permissions.Add((string)m_FldOperNames[aclOperation]);
}
}
foreach (ResourceOperation aclOperation in ace.ResourceOperations)
{
if (!permissions.Contains((string)m_ResOperNames[aclOperation]))
{
permissions.Add((string)m_ResOperNames[aclOperation]);
}
}
foreach (DatasourceOperation aclOperation in ace.DatasourceOperations)
{
if (!permissions.Contains((string)m_DSOperNames[aclOperation]))
{
permissions.Add((string)m_DSOperNames[aclOperation]);
}
}
}
}
}
return(permissions);
}
public byte[] CreateSecurityDescriptor(
AceCollection acl,
SecurityItemType itemType,
out string stringSecDesc)
{
// Creates a memory stream and serializes the ACL for storage.
BinaryFormatter bf = new BinaryFormatter();
using (MemoryStream result = new MemoryStream())
{
bf.Serialize(result, acl);
stringSecDesc = null;
return result.GetBuffer();
}
}
public StringCollection GetPermissions(string userName, IntPtr userToken, SecurityItemType itemType, byte[] secDesc)
{
StringCollection permissions = new StringCollection();
if (0 == String.Compare(userName, m_adminUserName, true,
CultureInfo.CurrentCulture))
{
foreach (CatalogOperation oper in m_CatOperNames.Keys)
{
if (!permissions.Contains((string)m_CatOperNames[oper]))
{
permissions.Add((string)m_CatOperNames[oper]);
}
}
foreach (ModelItemOperation oper in m_ModelItemOperNames.Keys)
{
if (!permissions.Contains((string)m_ModelItemOperNames[oper]))
{
permissions.Add((string)m_ModelItemOperNames[oper]);
}
}
foreach (ModelOperation oper in m_ModelOperNames.Keys)
{
if (!permissions.Contains((string)m_ModelOperNames[oper]))
{
permissions.Add((string)m_ModelOperNames[oper]);
}
}
foreach (CatalogOperation oper in m_CatOperNames.Keys)
{
if (!permissions.Contains((string)m_CatOperNames[oper]))
{
permissions.Add((string)m_CatOperNames[oper]);
}
}
foreach (ReportOperation oper in m_RptOperNames.Keys)
{
if (!permissions.Contains((string)m_RptOperNames[oper]))
{
permissions.Add((string)m_RptOperNames[oper]);
}
}
foreach (FolderOperation oper in m_FldOperNames.Keys)
{
if (!permissions.Contains((string)m_FldOperNames[oper]))
{
permissions.Add((string)m_FldOperNames[oper]);
}
}
foreach (ResourceOperation oper in m_ResOperNames.Keys)
{
if (!permissions.Contains((string)m_ResOperNames[oper]))
{
permissions.Add((string)m_ResOperNames[oper]);
}
}
foreach (DatasourceOperation oper in m_DSOperNames.Keys)
{
if (!permissions.Contains((string)m_DSOperNames[oper]))
{
permissions.Add((string)m_DSOperNames[oper]);
}
}
}
else
{
AceCollection acl = DeserializeAcl(secDesc);
foreach (AceStruct ace in acl)
{
if (0 == String.Compare(userName, ace.PrincipalName, true,
CultureInfo.CurrentCulture))
{
foreach (ModelItemOperation aclOperation in ace.ModelItemOperations)
{
if (!permissions.Contains((string)m_ModelItemOperNames[aclOperation]))
{
permissions.Add((string)m_ModelItemOperNames[aclOperation]);
}
}
foreach (ModelOperation aclOperation in ace.ModelOperations)
{
if (!permissions.Contains((string)m_ModelOperNames[aclOperation]))
{
permissions.Add((string)m_ModelOperNames[aclOperation]);
}
}
foreach (CatalogOperation aclOperation in
ace.CatalogOperations)
{
if (!permissions.Contains((string)m_CatOperNames[aclOperation]))
{
permissions.Add((string)m_CatOperNames[aclOperation]);
}
}
foreach (ReportOperation aclOperation in ace.ReportOperations)
{
if (!permissions.Contains((string)m_RptOperNames[aclOperation]))
{
permissions.Add((string)m_RptOperNames[aclOperation]);
}
}
foreach (FolderOperation aclOperation in ace.FolderOperations)
{
if (!permissions.Contains((string)m_FldOperNames[aclOperation]))
{
permissions.Add((string)m_FldOperNames[aclOperation]);
}
}
foreach (ResourceOperation aclOperation in ace.ResourceOperations)
{
if (!permissions.Contains((string)m_ResOperNames[aclOperation]))
{
permissions.Add((string)m_ResOperNames[aclOperation]);
}
}
foreach (DatasourceOperation aclOperation in ace.DatasourceOperations)
{
if (!permissions.Contains((string)m_DSOperNames[aclOperation]))
{
permissions.Add((string)m_DSOperNames[aclOperation]);
}
}
}
}
}
return(permissions);
}
private AceCollection DeserializeAcl(byte[] secDesc)
{
AceCollection acl = new AceCollection();
if (secDesc != null)
{
BinaryFormatter bf = new BinaryFormatter();
using (MemoryStream sdStream = new MemoryStream(secDesc))
{
acl = (AceCollection)bf.Deserialize(sdStream);
}
}
return acl;
}
public StringCollection GetPermissions(string userName, IntPtr userToken, SecurityItemType itemType, byte[] secDesc)
{
StringCollection permissions = new StringCollection();
//Check Overrides
if (IsSecurityOverride(userName))
{
permissions.AddRange(_catalogOperationNames.Select(t => t.Value).Distinct().ToArray());
permissions.AddRange(_reportOperationNames.Select(t => t.Value).Distinct().ToArray());
permissions.AddRange(_folderOperationNames.Select(t => t.Value).Distinct().ToArray());
permissions.AddRange(_resourceOperationNames.Select(t => t.Value).Distinct().ToArray());
permissions.AddRange(_datasetOperationNames.Select(t => t.Value).Distinct().ToArray());
permissions.AddRange(_modelOperationNames.Select(t => t.Value).Distinct().ToArray());
permissions.AddRange(_modelItemOperationNames.Select(t => t.Value).Distinct().ToArray());
}
else
{
AceCollection acl = DeserializeAcl(secDesc);
foreach (AceStruct ace in acl)
{
if (ValidateACLPrincipal(ace.PrincipalName, userName))
{
foreach (CatalogOperation aclOperation in ace.CatalogOperations)
{
if (!permissions.Contains((string)_catalogOperationNames[aclOperation]))
{
permissions.Add((string)_catalogOperationNames[aclOperation]);
}
}
foreach (ReportOperation aclOperation in ace.ReportOperations)
{
if (!permissions.Contains((string)_reportOperationNames[aclOperation]))
{
permissions.Add((string)_reportOperationNames[aclOperation]);
}
}
foreach (FolderOperation aclOperation in ace.FolderOperations)
{
if (!permissions.Contains((string)_folderOperationNames[aclOperation]))
{
permissions.Add((string)_folderOperationNames[aclOperation]);
}
}
foreach (ResourceOperation aclOperation in ace.ResourceOperations)
{
if (!permissions.Contains((string)_resourceOperationNames[aclOperation]))
{
permissions.Add((string)_resourceOperationNames[aclOperation]);
}
}
foreach (DatasourceOperation aclOperation in ace.DatasourceOperations)
{
if (!permissions.Contains((string)_datasetOperationNames[aclOperation]))
{
permissions.Add((string)_datasetOperationNames[aclOperation]);
}
}
foreach (ModelOperation aclOperation in ace.ModelOperations)
{
if (!permissions.Contains((string)_modelOperationNames[aclOperation]))
{
permissions.Add((string)_modelOperationNames[aclOperation]);
}
}
foreach (ModelItemOperation aclOperation in ace.ModelItemOperations)
{
if (!permissions.Contains((string)_modelItemOperationNames[aclOperation]))
{
permissions.Add((string)_modelItemOperationNames[aclOperation]);
}
}
}
}
}
return(permissions);
}
public override void Migrate()
{
if (!ShouldImport)
{
return;
}
var drivePath = Directory.Exists(Path.Combine(rootFolder, "data", user.Key, "files")) ?
Path.Combine(rootFolder, "data", user.Key) : null;
if (drivePath == null)
{
return;
}
matchingFileId = new Dictionary <object, int>();
var foldersDict = new Dictionary <string, Folder>();
if (folders != null)
{
foreach (var folder in folders)
{
var split = folder.Path.Split('/');
for (var i = 0; i < split.Length; i++)
{
var path = string.Join(Path.DirectorySeparatorChar.ToString(), split.Take(i + 1));
if (foldersDict.ContainsKey(path))
{
continue;
}
var parentId = i == 0 ? Global.FolderMy : foldersDict[string.Join(Path.DirectorySeparatorChar.ToString(), split.Take(i))].ID;
try
{
var newFolder = Global.FileStorageService.CreateNewFolder(parentId.ToString(), split[i]);
foldersDict.Add(path, newFolder);
matchingFileId.Add(newFolder.ID, folder.FileId);
}
catch (Exception ex)
{
Log($"Couldn't create folder {path}", ex);
}
}
}
}
if (files != null)
{
foreach (var file in files)
{
string[] maskPaths = file.Path.Split('/');
if (maskPaths[0] == "OwnCloud’s Files " + DateTime.Now.ToString("dd.MM.yyyy"))
{
maskPaths[0] = "files";
}
var maskPath = string.Join(Path.DirectorySeparatorChar.ToString(), maskPaths);
var parentPath = Path.GetDirectoryName(file.Path);
try
{
var realPath = Path.Combine(drivePath, maskPath);
using (var fs = new FileStream(realPath, FileMode.Open))
using (var fileDao = Global.DaoFactory.GetFileDao())
using (var folderDao = Global.DaoFactory.GetFolderDao())
{
var parentFolder = string.IsNullOrWhiteSpace(parentPath) ? folderDao.GetFolder(Global.FolderMy) : foldersDict[parentPath];
var newFile = new ASCFile
{
FolderID = parentFolder.ID,
Comment = FilesCommonResource.CommentCreate,
Title = Path.GetFileName(file.Path),
ContentLength = fs.Length
};
newFile = fileDao.SaveFile(newFile, fs);
matchingFileId.Add(newFile.ID, file.FileId);
}
}
catch (Exception ex)
{
Log($"Couldn't create file {parentPath}/{Path.GetFileName(file.Path)}", ex);
}
}
}
foreach (var item in matchingFileId)
{
var list = new ItemList <AceWrapper>();
var entryIsFile = files.Exists(el => el.FileId == item.Value) ? true : false;
var entry = entryIsFile ? files.Find(el => el.FileId == item.Value) : folders.Find(el => el.FileId == item.Value);
if (entry.Share.Count == 0)
{
continue;
}
foreach (var shareInfo in entry.Share)
{
if (shareInfo.ShareWith == null)
{
continue;
}
var shareType = GetPortalShare(shareInfo.Premissions, entryIsFile);
users.TryGetValue(shareInfo.ShareWith, out var userToShare);
groups.TryGetValue(shareInfo.ShareWith, out var groupToShare);
if (userToShare != null || groupToShare != null)
{
var entryGuid = userToShare == null ? groupToShare.Guid : userToShare.Guid;
list.Add(new AceWrapper
{
Share = shareType.Value,
SubjectId = entryGuid,
SubjectGroup = false
});
}
}
if (!list.Any())
{
continue;
}
var aceCollection = new AceCollection
{
Entries = new ItemList <string> {
(entryIsFile ? "file_" : "folder_") + (int)item.Key
},
Aces = list,
Message = null
};
try
{
Global.FileStorageService.SetAceObject(aceCollection, false);
}
catch (Exception ex)
{
Log($"Couldn't change file permissions for {aceCollection.Entries.First()}", ex);
}
}
}
public override void Migrate()
{
if (!ShouldImport)
{
return;
}
var tmpFolder = Path.Combine(Path.GetTempPath(), Path.GetFileNameWithoutExtension(user.Key));
try
{
ZipFile.ExtractToDirectory(user.Key, tmpFolder);
var drivePath = Path.Combine(tmpFolder, "Takeout", "Drive");
// Create all folders first
var foldersDict = new Dictionary <string, Folder>();
if (folders != null && folders.Count != 0)
{
foreach (var folder in folders)
{
var split = folder.Split(Path.DirectorySeparatorChar); // recursivly create all the folders
for (var i = 0; i < split.Length; i++)
{
var path = string.Join(Path.DirectorySeparatorChar.ToString(), split.Take(i + 1));
if (foldersDict.ContainsKey(path))
{
continue; // skip folder if it was already created as a part of another path
}
var parentId = i == 0 ? Global.FolderMy : foldersDict[string.Join(Path.DirectorySeparatorChar.ToString(), split.Take(i))].ID;
try
{
var createdFolder = Global.FileStorageService.CreateNewFolder(parentId.ToString(), split[i]);
path = path.Contains(newParentFolder + Path.DirectorySeparatorChar.ToString()) ? path.Replace(newParentFolder + Path.DirectorySeparatorChar.ToString(), "") : path;
foldersDict.Add(path, createdFolder);
}
catch (Exception ex)
{
Log($"Couldn't create folder {path}", ex);
}
}
}
}
//create default folder
if ((folders == null || folders.Count == 0) && (files != null && files.Count != 0))
{
var parentId = Global.FolderMy;
var createdFolder = Global.FileStorageService.CreateNewFolder(parentId.ToString(), newParentFolder);
foldersDict.Add(newParentFolder, createdFolder);
}
// Copy all files
var filesDict = new Dictionary <string, ASCFile>();
if (files != null && files.Count != 0)
{
foreach (var file in files)
{
var maskFile = file.Replace(ModuleName + " " + folderCreation + Path.DirectorySeparatorChar.ToString(), "");
var maskParentPath = Path.GetDirectoryName(maskFile);
// ToDo: maybe we should upload to root, if required folder wasn't created
try
{
var realPath = Path.Combine(drivePath, maskFile);
using (var fs = new FileStream(realPath, FileMode.Open))
using (var fileDao = Global.DaoFactory.GetFileDao())
using (var folderDao = Global.DaoFactory.GetFolderDao())
{
var parentFolder = string.IsNullOrWhiteSpace(maskParentPath) ? foldersDict[newParentFolder] : foldersDict[maskParentPath];
var newFile = new ASCFile
{
FolderID = parentFolder.ID,
Comment = FilesCommonResource.CommentCreate,
Title = Path.GetFileName(file),
ContentLength = fs.Length
};
newFile = fileDao.SaveFile(newFile, fs);
realPath = realPath.Contains(Path.DirectorySeparatorChar.ToString() + newParentFolder) ? realPath.Replace(Path.DirectorySeparatorChar.ToString() + newParentFolder, "") : realPath;
filesDict.Add(realPath, newFile);
}
}
catch (Exception ex)
{
Log($"Couldn't create file {maskParentPath}/{Path.GetFileName(file)}", ex);
}
}
}
var entries = filesDict
.ToDictionary(kv => kv.Key, kv => (FileEntry)kv.Value)
.Concat(foldersDict
.ToDictionary(kv => Path.Combine(drivePath, kv.Key), kv => (FileEntry)kv.Value))
.OrderBy(kv => kv.Value is ASCFile)
.ThenBy(kv => kv.Key.Count(c => Path.DirectorySeparatorChar.Equals(c)));
var favFolders = new ItemList <object>();
var favFiles = new ItemList <object>();
var fileSec = new FileSecurity(Global.DaoFactory);
foreach (var kv in entries)
{
if (TryReadInfoFile(kv.Key, out var info))
{
if (info.Starred)
{
if (kv.Value is ASCFile)
{
favFiles.Add(kv.Value.ID);
}
else
{
favFolders.Add(kv.Value.ID);
}
}
var list = new ItemList <AceWrapper>();
foreach (var shareInfo in info.Permissions)
{
if (shareInfo.Type == "user" || shareInfo.Type == "group")
{
var shareType = GetPortalShare(shareInfo);
users.TryGetValue(shareInfo.EmailAddress, out var userToShare);
groups.TryGetValue(shareInfo.Name, out var groupToShare);
if (shareType == null || (userToShare == null && groupToShare == null))
{
continue;
}
Func <FileEntry, Guid, bool> checkRights = null;
switch (shareType)
{
case ASCShare.ReadWrite:
checkRights = fileSec.CanEdit;
break;
case ASCShare.Comment:
checkRights = fileSec.CanComment;
break;
case ASCShare.Read:
checkRights = fileSec.CanRead;
break;
default: // unused
break;
}
var entryGuid = userToShare == null ? groupToShare.Guid : userToShare.Guid;
if (checkRights != null && checkRights(kv.Value, entryGuid))
{
continue; // already have rights, skip
}
list.Add(new AceWrapper
{
Share = shareType.Value,
SubjectId = entryGuid,
SubjectGroup = false
});
}
}
if (!list.Any())
{
continue;
}
var aceCollection = new AceCollection
{
Entries = new ItemList <string> {
(kv.Value is ASCFile ? "file_" : "folder_") + kv.Value.ID
},
Aces = list,
Message = null
};
try
{
Global.FileStorageService.SetAceObject(aceCollection, false);
}
catch (Exception ex)
{
Log($"Couldn't change file permissions for {aceCollection.Entries.First()}", ex);
}
}
}
if (favFolders.Any() || favFiles.Any())
{
Global.FileStorageService.AddToFavorites(favFolders, favFiles);
}
}
catch
{
throw;
}
finally
{
if (Directory.Exists(tmpFolder))
{
Directory.Delete(tmpFolder, true);
}
}
}
public StringCollection GetPermissions(string userName, IntPtr userToken,
SecurityItemType itemType, byte[] secDesc)
{
StringCollection permissions = new StringCollection();
if (IsAdmin(userName))
{
permissions.AddRange(_fullPermissions.ToArray());
}
else if (IsReportViewer(userName))
{
//permissions.AddRange(_fullPermissions.ToArray());
}
else
{
AceCollection acl = DeserializeAcl(secDesc);
foreach (AceStruct ace in acl)
{
if (0 == String.Compare(userName, ace.PrincipalName, true,
CultureInfo.CurrentCulture))
{
foreach (ModelItemOperation aclOperation in ace.ModelItemOperations)
{
if (!permissions.Contains(_modelItemOperNames[aclOperation]))
{
permissions.Add(_modelItemOperNames[aclOperation]);
}
}
foreach (ModelOperation aclOperation in ace.ModelOperations)
{
if (!permissions.Contains(_modelOperNames[aclOperation]))
{
permissions.Add(_modelOperNames[aclOperation]);
}
}
foreach (CatalogOperation aclOperation in ace.CatalogOperations)
{
if (!permissions.Contains(_catalogOperationNames[aclOperation]))
{
permissions.Add(_catalogOperationNames[aclOperation]);
}
}
foreach (ReportOperation aclOperation in ace.ReportOperations)
{
if (!permissions.Contains(_reportOperationNames[aclOperation]))
{
permissions.Add(_reportOperationNames[aclOperation]);
}
}
foreach (FolderOperation aclOperation in ace.FolderOperations)
{
if (!permissions.Contains(_folderOperationNames[aclOperation]))
{
permissions.Add(_folderOperationNames[aclOperation]);
}
}
foreach (ResourceOperation aclOperation in ace.ResourceOperations)
{
if (!permissions.Contains(_resourceOperationNames[aclOperation]))
{
permissions.Add(_resourceOperationNames[aclOperation]);
}
}
foreach (DatasourceOperation aclOperation in ace.DatasourceOperations)
{
if (!permissions.Contains(_dataSourceOperationNames[aclOperation]))
{
permissions.Add(_dataSourceOperationNames[aclOperation]);
}
}
}
}
}
return(permissions);
}
