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)); }
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)); }