private SyncDownSharedFolder GenerateSharedFolder(SharedFolder sharedFolder,
long revision,
IEnumerable <PasswordRecord> records,
IEnumerable <Team> teams,
bool hasKey)
{
var sf = new SyncDownSharedFolder
{
SharedFolderUid = sharedFolder.Uid,
Revision = revision,
Name = CryptoUtils.EncryptAesV1(Encoding.UTF8.GetBytes(sharedFolder.Name), sharedFolder.SharedFolderKey)
.Base64UrlEncode(),
ManageRecords = false,
ManageUsers = false,
DefaultManageRecords = true,
DefaultManageUsers = true,
DefaultCanEdit = true,
DefaultCanShare = true,
fullSync = true,
users = new[]
{
new SyncDownSharedFolderUser
{
Username = User,
ManageRecords = true,
ManageUsers = true
}
}
};
if (hasKey)
{
sf.KeyType = 1;
sf.SharedFolderKey = CryptoUtils.EncryptAesV1(sharedFolder.SharedFolderKey, DataKey).Base64UrlEncode();
}
if (records != null)
{
sf.records = records.Select(x => new SyncDownSharedFolderRecord
{
RecordUid = x.Uid,
RecordKey = CryptoUtils.EncryptAesV1(x.RecordKey, sharedFolder.SharedFolderKey).Base64UrlEncode(),
CanShare = false,
CanEdit = false
}).ToArray();
}
if (teams != null)
{
sf.teams = teams.Select(x => new SyncDownSharedFolderTeam
{
TeamUid = x.TeamUid,
Name = x.Name,
ManageRecords = true,
ManageUsers = true
}).ToArray();
}
return(sf);
}
//Helper Functions
private SharedFolder isShared(User thisUser, DriveItem thisFolder)
{
if (thisFolder.Shared != null)
{
var temp = new SharedFolder(thisFolder.Id, thisFolder.WebUrl, thisUser.Id);
var permissions = graphClient.Users[thisUser.Id].Drive.Items[thisFolder.Id].Permissions.Request().GetAsync().Result;
foreach (var permission in permissions)
{
// link test
if (permission.GrantedTo != null)
{
String assignedTo = permission.GrantedTo.User.Id;
if (assignedTo != thisUser.Id && exclusionCheck(assignedTo) && assignedTo != null)
{
temp.AddPermission(permission);
}
}
else
{
// is link
}
}
return(temp);
}
else
{
return(null);
}
}
private List <SharedFolder> recurseFolders(Microsoft.Graph.User user, DriveItem folder)
{
List <SharedFolder> partialResult = new List <SharedFolder>(); // return case variable
var childItems = graphClient.Users[user.Id].Drive.Items[folder.Id].Children.Request().GetAsync().Result; // list child items of inbound folder
System.Threading.Thread.Sleep(50); // spaces out API calls
foreach (var child in childItems)
{
if (child.Folder != null) // Check if item is a folder
{
Console.WriteLine(" . . . . Folder Debug " + child.Name);
if (child.Shared != null) // Check if folder is shared, if it is shared, check permissions and stop recursing
{
Console.Write(" (SHARED) ");
// Create folder object to store permissions
SharedFolder temp = new SharedFolder(child.Id, child.WebUrl, user.Id);
// Request Permissions on folder
var permissions = graphClient.Users[user.Id].Drive.Items[child.Id].Permissions.Request().GetAsync().Result;
// Loop Through all Permissions
int count = 0;
foreach (var permission in permissions)
{
String grantedTo = null;
if (permission.GrantedTo != null) // GrantedTo refers to an in tenant object that this folder is shared with
{
grantedTo = permission.GrantedTo.User.Id;
if (grantedTo != user.Id && exclusionCheck(grantedTo) && grantedTo != null)
{
// permission is found
temp.SharedWith.Add(permission);
// output
file.WriteLine(user.DisplayName + ";" + user.Id + ";" + child.Id + ";" + permission.Id + ";" + grantedTo);
System.Console.WriteLine(user.DisplayName + ";" + user.Id + ";" + child.Id + ";" + permission.Id + ";" + grantedTo);
file.Flush();
count++;
}
}
else // exception case indicates an external link share
{
temp.SharedWith.Add(permission);
}
}
if (count > 0)
{
partialResult.Add(temp);
}
}
else // if folder is not shared, go down one level
{
partialResult.AddRange(recurseFolders(user, child));
}
}
}
return(partialResult);
}
public string FindSendAsAddress(ZPushAccount zpush, SharedFolder folder)
{
string address = folder.SendAsAddress;
if (!string.IsNullOrWhiteSpace(address))
{
// Make sure it's in the registry
StoreSyncIdAddress(zpush, folder);
return(address);
}
// Check the registry
string addressSync = zpush.GetSendAsAddress(folder.SyncId);
string addressBackend = zpush.GetSendAsAddress(folder.BackendId);
// If we have no address on sync id, or it differs from the one on backend id, backend id wins, as that's the one set by the dialog
if (string.IsNullOrWhiteSpace(addressSync) || !addressSync.Equals(addressBackend))
{
folder.SendAsAddress = address = addressBackend;
// Resolved now, store on sync id
StoreSyncIdAddress(zpush, folder);
}
else
{
address = addressSync;
}
return(address);
}
private void OnConnectionRequest(SyncFilesRequest arg2, ConnectionRequest connectionRequest, HttpRequestEventArgs e)
{
try
{
var token = Guid.NewGuid();
_connectionStateManager.Add(connectionRequest.Login, token.ToString());
var folders = _userTableDataBase.GetAvailableFolders(connectionRequest.Login);
var response = new ConnectionResponse()
{
Token = token.ToString()
};
foreach (var folder in folders)
{
var sharedFolder = new SharedFolder();
sharedFolder.Files.AddRange(GetListOfPath(folder));
response.Shared_folders.Add(sharedFolder);
}
ApiController.SendResponse(e, response);
}
catch (Exception exception)
{
_logger.Error(() => $"{exception}");
throw;
}
}
public void CreateTest()
{
var controller = new SharedFoldersController();
var context = CreateMockContext(controller, "Create");
controller.db = db;
controller.RoleManager = CreateRoleManager();
var mockUser = CreateMockUser("jethro");
db.CurrentUser = mockUser;
context.HttpContext.Setup(r => r.User).Returns(mockUser);
var sharedFolder = new SharedFolder {
Name = "Test shared folder", Description = "This is a test"
};
var usersRole = controller.RoleManager.FindByNameAsync(Roles.Users);
usersRole.Wait();
var usersRole_Id = usersRole.Result.Id;
string[] permissions = new string[] { usersRole_Id };
var result = controller.Create(sharedFolder, permissions);
Assert.IsInstanceOfType(result.Result, typeof(RedirectResult));
var viewResult = (RedirectResult)result.Result;
Assert.IsTrue(viewResult.Url.Contains(sharedFolder.Slug));
}
private void StoreSyncIdAddress(ZPushAccount zpush, SharedFolder folder)
{
if (!string.IsNullOrWhiteSpace(folder.SyncId?.ToString()) && !folder.SyncId.Equals(folder.BackendId))
{
zpush.SetSendAsAddress(folder.SyncId, folder.SendAsAddress);
}
}
/// <summary>
/// Adds a share.
/// </summary>
/// <param name="folder">The folder to share.</param>
/// <param name="state">The share state. This may be null to add a default share</param>
/// <returns>The share information</returns>
internal SharedFolder AddShare(AvailableFolder folder, SharedFolder state)
{
state = state ?? CreateDefaultShare(folder);
_currentShares[folder.BackendId] = state;
CheckDirty();
return(state);
}
private void AddFolderNode(KTreeNode node, KTreeNodes children, AvailableFolder folder)
{
StoreTreeNode rootNode = (StoreTreeNode)this.Children.Parent;
// Create the tree node
SharedFolder share = rootNode.GetInitialShareState(folder);
FolderTreeNode child = new FolderTreeNode(rootNode, folder, share);
ApplyReadOnly(child, child.IsReadOnly);
// Add
children.Add(child);
// Add the children
foreach (AvailableFolder childFolder in folder.Children.OrderBy(f => f, new FolderComparer(false)))
{
AddFolderNode(child, child.Children, childFolder);
}
// Set the initial share state
if (share != null)
{
child.IsChecked = true;
}
// Add the share; it might have become checked by any of the child nodes
if (child.IsShared)
{
rootNode.AddShare(folder, share);
}
}
public void MakeAccountPath_returns_shared_folder_name_when_group_is_null_or_blank()
{
var folder = new SharedFolder("id", "folder", null);
Assert.Equal("folder", Parser.MakeAccountPath(null, folder));
Assert.Equal("folder", Parser.MakeAccountPath("", folder));
}
private void AddSharedFolderDialog_Shown(object sender, EventArgs args)
{
BusyText = Properties.Resources.SharedFolders_Fetching_Label;
KUITask
.New((ctx) =>
{
// TODO: bind cancellation token to Cancel button
// Fetch current shares
ICollection <SharedFolder> folders = _folders.GetCurrentShares(ctx.CancellationToken);
// Find the initial folder if required
if (_initialSyncId != null)
{
_initialFolder = folders.FirstOrDefault(f => f.SyncId == _initialSyncId);
}
// Group by store and folder id
return(folders.GroupBy(f => f.Store)
.ToDictionary(group => group.Key,
group => group.ToDictionary(folder => folder.BackendId)));
})
.OnSuccess(InitialiseTree, true)
.OnError((e) =>
{
UI.ErrorUtil.HandleErrorNew(typeof(FeatureSharedFolders), "Exception fetching shared folders for account {0}", e,
Properties.Resources.SharedFolders_Fetching_Title,
Properties.Resources.SharedFolders_Fetching_Failure,
_account.DisplayName);
DialogResult = DialogResult.Cancel;
})
.Start(this)
;
}
public async Task <FolderDto> FollowFolder(Guid UserId, Guid FolderId, string left, string top)
{
var sharedFolder = _liveContext.SharedFolders.FirstOrDefault(x => x.UserId == UserId && x.FolderId == FolderId);
var folder = _liveContext.Folders.Include(x => x.UserYouTubes)
.Include(x => x.UserImages)
.Include(x => x.UserSpotify)
.FirstOrDefault(x => x.ID == FolderId);
if (folder != null && sharedFolder == null)
{
if (sharedFolder == null && folder.IsShared)
{
sharedFolder = new SharedFolder(UserId, FolderId, left, top);
_liveContext.SharedFolders.Add(sharedFolder);
//folder.AddFollower();
_liveContext.Update(folder);
await _liveContext.SaveChangesAsync();
//return _autoMapper.Map<FolderDto>(folder);
var folderDto = _autoMapper.Map <FolderDto>(folder);
var followers = _liveContext.SharedFolders.Where(x => x.FolderId == folder.ID).ToList().Count;
folderDto.followers = followers;
folderDto.followed = true;
return(folderDto);
}
}
return(null);
}
public ActionResult DeleteConfirmed(int id)
{
SharedFolder sharedFolder = db.SharedFolders.Find(id);
db.SharedFolders.Remove(sharedFolder);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public void SharedFolder_properties_are_set()
{
var id = "1234567890";
var name = "name";
var folder = new SharedFolder(id, name, TestData.EncryptionKey);
Assert.AreEqual(id, folder.Id);
Assert.AreEqual(name, folder.Name);
Assert.AreEqual(TestData.EncryptionKey, folder.EncryptionKey);
}
public ActionResult Edit([Bind(Include = "Id,Name,ApplicationUserId,LinkToDokument")] SharedFolder sharedFolder)
{
if (ModelState.IsValid)
{
db.Entry(sharedFolder).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.ApplicationUserId = new SelectList(db.Users, "Id", "FirstName", sharedFolder.ApplicationUserId);
return(View(sharedFolder));
}
public void SharedFolder_properties_are_set()
{
var id = "1234567890";
var name = "name";
var folder = new SharedFolder(id, name, TestData.EncryptionKey);
Assert.AreEqual(id, folder.Id);
Assert.AreEqual(name, folder.Name);
Assert.AreEqual(TestData.EncryptionKey, folder.EncryptionKey);
}
private SharedFolder CreateDefaultShare(AvailableFolder folder)
{
SharedFolder share = new SharedFolder(folder, DefaultNameForFolder(folder));
// Default send as for mail folders
if (folder.Type.IsMail())
{
share = share.WithFlagSendAsOwner(true);
}
return(share);
}
public List<SharedFolder> getFolder()
{
List<SharedFolder> list = new List<SharedFolder>();
SQLiteDataReader reader = this.query("SELECT * FROM sharedfolder ORDER BY id");
while(reader.Read())
{
DirectoryInfo dir = new DirectoryInfo((string)reader["path"]);
SharedFolder folder = new SharedFolder(dir);
list.Add(folder);
}
return list;
}
public void SharedFolder_properties_are_set()
{
var id = "1234567890";
var name = "name";
var key = "blah".ToBytes();
var folder = new SharedFolder(id, name, key);
Assert.Equal(id, folder.Id);
Assert.Equal(name, folder.Name);
Assert.Equal(key, folder.EncryptionKey);
}
public async Task <ActionResult> DeleteConfirmed(long id)
{
var sharedFolders = SharedFolder.GetEditableFolders(db, User);
SharedFolder sharedFolder = await sharedFolders.Include(f => f.Permissions).Include(f => f.Files).FindAsync(id);
db.Permissions.RemoveRange(sharedFolder.Permissions);
db.SharedFolders.Remove(sharedFolder);
await db.SaveChangesAsync();
SetSuccessMessage(string.Format("Folder {0} was deleted successfully!", sharedFolder.Name));
return(RedirectToAction("Index"));
}
protected override void OnCheckStateChanged()
{
// Update share state
if (CheckState == System.Windows.Forms.CheckState.Unchecked)
{
_store.RemoveShare(_folder);
}
else
{
_share = _store.AddShare(_folder, _share);
}
base.OnCheckStateChanged();
}
// GET: SharedFolders/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
SharedFolder sharedFolder = db.SharedFolders.Find(id);
if (sharedFolder == null)
{
return(HttpNotFound());
}
return(View(sharedFolder));
}
public async Task <ActionResult> Create([Bind(Include = AllowedFields)] SharedFolder sharedFolder, string[] permissions)
{
if (ModelState.IsValid)
{
PrepareFolder(sharedFolder, permissions);
db.SharedFolders.Add(sharedFolder);
await db.SaveChangesAsync();
return(Redirect("/Shared/" + sharedFolder.Slug));
}
return(View(sharedFolder));
}
public async Task <ActionResult> Index(long?Id)
{
if (Settings.SharedFoldersRootPermissions.Contains(PublicRole.Id) ||
Roles.UserInAnyRole(User, RoleManager, Settings.SharedFoldersRootPermissions.Split(',')))
{
var folders = await SharedFolder.GetAvailableFolders(db, User, UserManager, RoleManager, false, true, Id).ToListAsync();
return(Auto(folders));
}
else
{
return(RedirectToAction("Login", "Account", new { returnUrl = Request.RawUrl.ToAppPath(HttpContext) }));
}
}
// GET: SharedFolders/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
SharedFolder sharedFolder = db.SharedFolders.Find(id);
if (sharedFolder == null)
{
return(HttpNotFound());
}
ViewBag.ApplicationUserId = new SelectList(db.Users, "Id", "FirstName", sharedFolder.ApplicationUserId);
return(View(sharedFolder));
}
private string UpgradeSharedFolderAddress(ZPushAccount zpush, SharedFolder folder)
{
string address = FindSendAsAddress(zpush, folder.Store);
if (string.IsNullOrWhiteSpace(address))
{
return(null);
}
// Store it
folder.SendAsAddress = address;
StoreSyncIdAddress(zpush, folder);
zpush.SetSendAsAddress(folder.BackendId, address);
return(address);
}
// GET: SharedFolders/Delete/5
public async Task <ActionResult> Delete(long?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var sharedFolders = SharedFolder.GetEditableFolders(db, User);
SharedFolder sharedFolder = await sharedFolders.FindAsync(id.Value);
if (sharedFolder == null)
{
return(HttpNotFound());
}
return(View(sharedFolder));
}
private void MailEvents_Respond(IMailItem mail, IMailItem response)
{
Logger.Instance.Trace(this, "Responding to mail, checking");
using (IStore store = mail.GetStore())
{
ZPushAccount zpush = Watcher.Accounts.GetAccount(store);
Logger.Instance.Trace(this, "Checking ZPush: {0}", zpush);
if (zpush != null)
{
// Check if the containing folder is a shared folder
using (IFolder parent = mail.Parent)
{
Logger.Instance.Trace(this, "Checking, Parent folder: {0}", parent.Name);
SharedFolder shared = _sharedFolders.GetSharedFolder(parent);
if (shared != null)
{
Logger.Instance.Trace(this, "Checking, Shared folder: {0}, flags={1}", shared, shared?.Flags);
}
else
{
Logger.Instance.Trace(this, "Not a shared folder");
}
if (shared != null && shared.FlagSendAsOwner)
{
Logger.Instance.Trace(this, "Checking, Shared folder owner: {0}", shared.Store.UserName);
// It's a shared folder, use the owner as the sender if possible
using (IRecipient recip = FindSendAsSender(zpush, shared.Store))
{
Logger.Instance.Trace(this, "Checking, Shared folder owner recipient: {0}", recip.Name);
if (recip != null && recip.IsResolved)
{
Logger.Instance.Trace(this, "Sending as: {0}", recip.Address);
using (IAddressEntry address = recip.GetAddressEntry())
{
response.SetSender(address);
}
}
else
{
Logger.Instance.Error(this, "Unable to resolve sender: {0}", shared.Store.UserName);
}
}
}
}
}
}
}
private void UpdateSendAsAddresses(ZPushAccount zpush, ICollection <SharedFolder> shares, bool checkUpgradeFolders)
{
SharedFolder firstFailure = null;
foreach (SharedFolder folder in shares)
{
if (!folder.FlagSendAsOwner)
{
continue;
}
// Resolve it
string address = FindSendAsAddress(zpush, folder);
if (checkUpgradeFolders && address == null)
{
// This is an update from an old shared folder. See if it can be resolved
address = UpgradeSharedFolderAddress(zpush, folder);
if (address == null)
{
// Still not resolved, mark a failure for later
if (firstFailure == null)
{
firstFailure = folder;
}
}
}
}
if (firstFailure != null)
{
ThisAddIn.Instance.InUI(() =>
{
if (MessageBox.Show(ThisAddIn.Instance.Window,
string.Format(Properties.Resources.SharedFolders_SendAsUpdateFailed_Label, firstFailure.Name),
Properties.Resources.SharedFolders_SendAsFailed_Title,
MessageBoxButtons.YesNo,
MessageBoxIcon.Warning
) == DialogResult.Yes)
{
SharedFoldersDialog dialog = new SharedFoldersDialog(_sharedFolders, zpush, firstFailure.SyncId);
dialog.SuppressInitialSendAsWarning = true;
dialog.ShowDialog();
}
}, false);
}
}
public FolderTreeNode(StoreTreeNode store, AvailableFolder folder, SharedFolder share)
{
this._store = store;
this._folder = folder;
this._share = share;
this.Text = folder.Name;
// Image
// TODO: clean this up
int index = ((int)OutlookConstants.BASIC_SYNC_TYPES[(int)folder.Type]) - 1;
if (index < 0 || index >= store.Owner.Images.Images.Count - 1)
{
index = 0;
}
ImageIndex = index;
}
private SharedFolder CreateDefaultShare(AvailableFolder folder)
{
SharedFolder share = new SharedFolder(folder, DefaultNameForFolder(folder));
// Default send as for mail folders if the address can be determined
/*using (IRecipient sendAs = _featureSendAs?.FindSendAsSender(_account, null, folder.BackendId, null, _sendAsAddress))
* {
* if (sendAs != null)
* {
* share = share.WithFlagSendAsOwner(true).WithSendAsAddress(sendAs.Address);
* }
* else
* {
* share = share.WithFlagSendAsOwner(false).WithSendAsAddress(null);
* }
* }*/
return(share);
}
public async Task <ActionResult> Edit([Bind(Include = AllowedFields)] SharedFolder sharedFolder, string[] permissions)
{
if (ModelState.IsValid)
{
var sharedFolders = SharedFolder.GetEditableFolders(db, User);
SharedFolder actual = await sharedFolders.FindAsync(sharedFolder.Id);
if (actual == null)
{
return(HttpNotFound());
}
actual.Update(sharedFolder);
PrepareFolder(actual, permissions);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(sharedFolder));
}
