private static void TryClearHistory()
{
using (var database = DatabaseConnections.CreateInstance())
{
database.ClearHistory();
}
}
private List <int?> TryLoadFavoritesFromDatabase()
{
using (Database database = DatabaseConnections.CreateInstance())
{
return(database.GetFavoritesInGroup(this.Id).ToList());
}
}
private static List <DbCredentialSet> TryLoadFromDatabase()
{
using (var database = DatabaseConnections.CreateInstance())
{
return(database.CredentialBase.OfType <DbCredentialSet>().ToList());
}
}
private void TryLoadImageFromDatabase(DbFavorite favorite)
{
using (Database database = DatabaseConnections.CreateInstance())
{
byte[] imageData = database.GetFavoriteIcon(favorite.Id);
this.AssignImageByLoadedData(favorite, imageData);
}
}
private static void DeleteFromDatabase(DbCredentialSet credentailToRemove)
{
using (var database = DatabaseConnections.CreateInstance())
{
database.CredentialBase.Attach(credentailToRemove);
database.CredentialBase.Remove(credentailToRemove);
database.SaveImmediatelyIfRequested();
}
}
private static void AddToDatabase(DbCredentialSet credentialToAdd)
{
using (var database = DatabaseConnections.CreateInstance())
{
database.CredentialBase.Add(credentialToAdd);
database.SaveImmediatelyIfRequested();
database.Cache.Detach(credentialToAdd);
}
}
private static void TryAddToDatabase(DbFavorite historyTarget)
{
using (var database = DatabaseConnections.CreateInstance())
{
var userSid = WindowsUserIdentifiers.GetCurrentUserSid();
// store holds dates in UTC
database.InsertHistory(historyTarget.Id, Moment.Now, userSid);
}
}
private void TryUpdateGroup(IGroup group)
{
using (var database = DatabaseConnections.CreateInstance())
{
var toUpdate = group as DbGroup;
database.Cache.Attach(toUpdate);
this.TrySaveAndReport(toUpdate, database);
}
}
private ProtocolOptions LoadPropertiesFromDatabase()
{
using (Database database = DatabaseConnections.CreateInstance())
{
string serializedProperties = database.GetProtocolPropertiesByFavorite(this.favorite.Id);
Type propertiesType = this.favorite.protocolProperties.GetType();
return(Serialize.DeSerializeXML(serializedProperties, propertiesType) as ProtocolOptions);
}
}
private static List <DbGroup> TryLoadFromDatabase()
{
using (var database = DatabaseConnections.CreateInstance())
{
var groups = database.Groups.ToList();
database.Cache.DetachAll(groups);
return(groups);
}
}
private void TryUpdateFavorite(IFavorite favorite)
{
using (Database database = DatabaseConnections.CreateInstance())
{
var toUpdate = favorite as DbFavorite;
database.Cache.AttachFavorite(toUpdate);
this.TrySaveAndReportFavoriteUpdate(toUpdate, database);
}
}
private void TryRebuild()
{
using (var database = DatabaseConnections.CreateInstance())
{
var emptyGroups = this.DeleteEmptyGroupsFromDatabase(database);
database.SaveImmediatelyIfRequested();
var toReport = this.DeleteFromCache(emptyGroups);
this.dispatcher.ReportGroupsDeleted(toReport);
}
}
private void TryApplyValue(ApplyValueParams applyParams)
{
using (Database database = DatabaseConnections.CreateInstance())
{
var dbFavorites = applyParams.Favorites.Cast <DbFavorite>().ToList();
database.Cache.AttachAll(dbFavorites);
applyParams.Action(applyParams.Favorites, applyParams.ValueToApply);
this.SaveAndReportFavoritesUpdated(database, dbFavorites, applyParams.Favorites);
}
}
private void CommitNewMastrerPassord(string connectionString)
{
using (this.database = DatabaseConnections.CreateInstance(connectionString))
{
UpdateStoredPasswords();
this.database.UpdateMasterPassword(this.newStoredKey);
this.database.SaveChanges();
}
this.database = null;
}
private void TryLoadDetailsFromDatabase()
{
using (Database database = DatabaseConnections.CreateInstance())
{
database.Favorites.Attach(this.favorite);
this.LoadReferences(database);
this.LoadFieldsFromReferences();
database.Cache.DetachFavorite(this.favorite);
}
}
private void UpdateFavoritesMembershipInDatabase(List <IFavorite> favorites)
{
using (Database database = DatabaseConnections.CreateInstance())
{
foreach (DbFavorite favorite in favorites)
{
database.InsertFavoritesInGroup(favorite.Id, this.Id);
this.AddToCachedIds(favorite);
}
}
}
private void RemoveFavoritesFromDatabase(List <IFavorite> favorites)
{
using (Database database = DatabaseConnections.CreateInstance())
{
foreach (DbFavorite favorite in favorites)
{
database.DeleteFavoritesInGroup(favorite.Id, this.Id);
this.RemoveFromCachedIds(favorite);
}
}
}
private SortableList <IFavorite> TryLodFromDatabase(string historyDateKey)
{
using (var database = DatabaseConnections.CreateInstance())
{
var interval = HistoryIntervals.GetIntervalByName(historyDateKey);
// store holds dates in UTC
var favoriteIds = database.GetFavoritesHistoryByDate(interval.From, interval.To).ToList();
var intervalFavorites =
this.favorites.Cast <DbFavorite>().Where(favorite => favoriteIds.Contains(favorite.Id));
return(Data.Favorites.OrderByDefaultSorting(intervalFavorites));
}
}
private void TryUpdate(ICredentialSet toUpdate)
{
using (var database = DatabaseConnections.CreateInstance())
{
var credentialToUpdate = toUpdate as DbCredentialSet;
database.CredentialBase.Attach(credentialToUpdate);
database.Cache.MarkAsModified(credentialToUpdate);
database.SaveImmediatelyIfRequested();
database.Cache.Detach(credentialToUpdate);
this.cache.Update(credentialToUpdate);
}
}
private void TryAdd(List <IFavorite> favorites)
{
using (Database database = DatabaseConnections.CreateInstance())
{
List <DbFavorite> toAdd = favorites.Cast <DbFavorite>().ToList();
database.AddAll(toAdd);
this.UpdateIconInDatabase(database, toAdd);
database.SaveImmediatelyIfRequested();
database.Cache.DetachAll(toAdd);
this.cache.Add(toAdd);
this.dispatcher.ReportFavoritesAdded(favorites);
}
}
private void TryApplyCredentials(List <IFavorite> selectedFavorites, ICredentialSet credential)
{
using (Database database = DatabaseConnections.CreateInstance())
{
var dbFavorites = selectedFavorites.Cast <DbFavorite>().ToList();
Data.Favorites.ApplyCredentialsToFavorites(selectedFavorites, credential);
database.Cache.AttachAll(dbFavorites);
// here we have to mark it modified, because caching detail properties
// sets proper credential set reference
database.Cache.MarkAsModified(dbFavorites);
this.batchActions.SaveAndReportFavoritesUpdated(database, dbFavorites, selectedFavorites);
}
}
private void TryAdd(IGroup group)
{
using (var database = DatabaseConnections.CreateInstance())
{
var toAdd = group as DbGroup;
database.AddToGroups(toAdd);
database.SaveImmediatelyIfRequested();
database.Cache.DetachGoup(toAdd);
this.cache.Add(toAdd);
this.dispatcher.ReportGroupsAdded(new List <IGroup> {
toAdd
});
}
}
private void TryDelete(IGroup group)
{
using (var database = DatabaseConnections.CreateInstance())
{
var toDelete = group as DbGroup;
var changedFavorites = group.Favorites;
this.SetChildsToRoot(database, toDelete);
database.Groups.Attach(toDelete);
database.Groups.Remove(toDelete);
database.SaveImmediatelyIfRequested();
this.FinishGroupRemove(group);
this.dispatcher.ReportFavoritesUpdated(changedFavorites);
}
}
private void TryDelete(List <IFavorite> favorites)
{
using (Database database = DatabaseConnections.CreateInstance())
{
List <DbFavorite> favoritesToDelete = favorites.Cast <DbFavorite>().ToList();
List <DbCredentialBase> redundantCredentialBase = SelectRedundantCredentialBase(favoritesToDelete);
this.DeleteFavoritesFromDatabase(database, favoritesToDelete);
database.SaveImmediatelyIfRequested();
database.RemoveRedundantCredentialBase(redundantCredentialBase);
database.SaveImmediatelyIfRequested();
this.groups.RefreshCache();
this.FinishRemove(favorites, favoritesToDelete);
}
}
private static List <DbGroup> TryLoadFromDatabase(List <DbGroup> toRefresh)
{
using (var database = DatabaseConnections.CreateInstance())
{
if (toRefresh != null)
{
database.Cache.AttachAll(toRefresh);
}
((IObjectContextAdapter)database).ObjectContext.Refresh(RefreshMode.StoreWins, database.Groups);
var groups = database.Groups.Include("ParentGroup").ToList();
database.Cache.DetachAll(groups);
return(groups);
}
}
private List <DbFavorite> TryLoadFromDatabase()
{
string[] knownProtocols = this.connectionManager.GetAvailableProtocols();
using (Database database = DatabaseConnections.CreateInstance())
{
// to list because Linq to entities allows only cast to primitive types.
// cant use connectionManager.IsKnownProtocol because it cant be translated to serverside query.
List <DbFavorite> favorites = database.Favorites
.Where(f => knownProtocols.Contains(f.Protocol))
.ToList();
database.Cache.DetachAll(favorites);
favorites.ForEach(this.PrepareFavorite);
return(favorites);
}
}
private void TryUpdateFavorite(IFavorite favorite, List <IGroup> newGroups)
{
using (Database database = DatabaseConnections.CreateInstance())
{
var toUpdate = favorite as DbFavorite;
database.Cache.AttachFavorite(toUpdate);
List <IGroup> addedGroups = database.AddToDatabase(newGroups);
// commit newly created groups, otherwise we cant add into them
database.SaveImmediatelyIfRequested();
UpdateGroupsMembership(favorite, newGroups);
database.SaveImmediatelyIfRequested();
this.dispatcher.ReportGroupsAdded(addedGroups);
this.TrySaveAndReportFavoriteUpdate(toUpdate, database);
}
}
