public OfflineOrOnlineAdminstrationChoseViewmodel(IView view)
{
_view = view;
OfflineCommand = new RelayCommand(async(object obj) =>
{
_view.Disable();
SQLiteStarter starter = new SQLiteStarter();
IUserProvider desktopUserProvider = ServiceResolver.GetContainer().GetInstance <IUserProvider>();
desktopUserProvider.SetUserId(LoginRepository.Instance.CurrentUser.ID);
starter.CreateDBIfNotExists();
// starter.TestSeedDb();
Properties.Settings settings = new Properties.Settings();
if (RememberChoice)
{
settings.ChoiceIsOnline = false;
settings.RememberOnlineChoice = true;
settings.Save();
}
else
{
settings.RememberOnlineChoice = false;
settings.Save();
}
await RepositoryResolver.GetRepository <ITransactionRepository>().CreateInitialFilling();
new MainWindow().Show();
_view.Close();
});
}
public async Task <LoginResult> Login(string emailAdress, string password)
{
LoginResult result = new LoginResult();
var credentials = CredentialUtil.GetCredential("BalanceKeeper.Desktop" + emailAdress);
if (emailAdress != null && credentials != null && credentials.Username == emailAdress && password == credentials.Password)
{
result.IsError = false;
SetCurrentUser(emailAdress);
SQLiteStarter starter = new SQLiteStarter();
starter.Start(new Action(() =>
{
IUserProvider desktopUserProvider = ServiceResolver.GetContainer().GetInstance <IUserProvider>();
desktopUserProvider.SetUserId(LoginRepository.Instance.CurrentUser.ID);
}));
starter.CreateDBIfNotExists();
await RepositoryResolver.GetRepository <ITransactionRepository>().CreateInitialFilling();
}
else
{
result.IsError = true;
result.ErrorType = LoginErrorType.WrongCredentials;
}
return(await Task <LoginResult> .FromResult(result));
}
private void OnRelationEdited(object sender, EventArgs e)
{
var indexOfItem = importedRelationsPage.ImportResult.ImportedRelations.IndexOf(editRelation);
importedRelationsPage.ImportResult.ImportedRelations.Remove(editRelation);
importedRelationsPage.ImportResult.ImportedRelations.Insert(indexOfItem, Relation);
UpdateTaskNotifier = new NotifyTaskCompletion <bool>(RepositoryResolver.GetRepository <ITransactionRepository>().SynchronizeTransactionAndRelationCategoriesAsync(Relation.ID), OnRelationSynced);
}
public void GetRepository_ReturnsCorrectImplementationForBiscuit()
{
var resolver = new RepositoryResolver(testConfiguration);
var result = resolver.GetRepository <Biscuit>();
Assert.True(result.GetType() == typeof(BiscuitRepository));
}
private void DeleteTransaction(object obj)
{
EditTransactionNotifier = new NotifyTaskCompletion <bool>(RepositoryResolver.GetRepository <ITransactionRepository>().DeleteAsync(EditingItem),
(s, e) =>
{
Result = true;
_view.Close();
});
}
public CategoriesViewmodel(MainViewmodel mainViewmodel)
: base(RepositoryResolver.GetRepository <ICategoryRepository>())
{
_mainViewmodel = mainViewmodel;
_mainCategoriesRepository = RepositoryResolver.GetRepository <IMainCategoryRepository>();
LoadMainCategories();
_searchTerm = string.Empty;
MaintainMainCategoriesCommand = new RelayCommand(async(obj) => await MaintainMainCategoriesAsync(), CanMaintainMainCategories);
}
public RelationsViewmodel(MainViewmodel mainViewmodel, IDialogCoordinator instance)
: base(RepositoryResolver.GetRepository <IRelationRepository>())
{
dialogCoordinator = instance;
_mainViewmodel = mainViewmodel;
_categoryRepository = RepositoryResolver.GetRepository <ICategoryRepository>();
_transactionRepository = RepositoryResolver.GetRepository <ITransactionRepository>();
AddCategoryToRelationCommand = new RelayCommand(AddCategoryToRelation, CanAddCategoryToRelation);
LoadCategories();
}
private void AppendLookupList(ScaffoldViewData <T> viewData, PropertyInfo property)
{
var repository = RepositoryResolver.GetRepository(property.PropertyType);
// get the items
object items = repository.GetAll();
// add the items to the viewData
viewData.WithLookupList(property.PropertyType, items);
}
private void SaveTransaction(object obj)
{
EditTransactionNotifier = new NotifyTaskCompletion <Transaction>(RepositoryResolver.GetRepository <ITransactionRepository>().UpdateAsync(EditingItem.ID, EditingItem),
(s, e) =>
{
NotifyTaskCompletion <Transaction> sender = (NotifyTaskCompletion <Transaction>)s;
RepositoryResolver.GetRepository <ITransactionRepository>().UntrackItem(sender.Result);
Result = true;
_view.Close();
});
}
public StatisticsViewmodel(MainViewmodel mainViewmodel, IStatisticsView statisticsView)
{
_mainViewmodel = mainViewmodel;
this._statisticsView = statisticsView;
CurrentExecutingTasks = new ObservableCollection <TaskExecutorWrapper>();
_repository = RepositoryResolver.GetRepository <ICategoriesStatisticsRepository>();
FromDate = DateTime.Now.AddMonths(-1);
ToDate = DateTime.Now;
RemoveActionIfFaultedCommand = new RelayCommand(RemoveActionIfFaulted);
RefreshCommand = new RelayCommand(Refresh);
Refresh(null);
EditTransactionCommand = new RelayCommand(async(obj) => await EditTransactionAsync((Transaction)obj));
}
public TransActionsViewmodel(MainViewmodel mainViewmodel)
: base(RepositoryResolver.GetRepository <ITransactionRepository>())
{
_mainViewmodel = mainViewmodel;
_relationRepository = RepositoryResolver.GetRepository <IRelationRepository>();
_categoryRepository = RepositoryResolver.GetRepository <ICategoryRepository>();
FromDate = DateTime.Now.AddMonths(-1);
ToDate = DateTime.Now;
LoadRelations();
LoadCategories();
AddCategoryToTransactionCommand = new RelayCommand(AddCategoryToTransaction, CanAddCategoryToTransaction);
ImportCommand = new RelayCommand(async(obj) => await ImportTransactionsAsync());
}
public SelectFilePageViewmodel(ImportWizardViewmodel wizardViewmodel) : base(wizardViewmodel)
{
Content = new SelectFilePage()
{
DataContext = this
};
OpenFileCommand = new RelayCommand(OpenFile);
StartImportCommand = new RelayCommand(StartImport, CanStartImport);
Banks = new List <Bank>();
Banks.Add(ING);
Banks.Add(ASN);
CustomBank.DescriptionControl.DataContext = CustomBank;
Banks.Add(CustomBank);
_ingRepository = RepositoryResolver.GetRepository <IINGRepository>();
_asnRepository = RepositoryResolver.GetRepository <IASNRepository>();
_customImportRepository = RepositoryResolver.GetRepository <ICustomImportRepository>();
}
public async Task <bool> SynchronizeTransactionAndRelationCategoriesAsync(long relationId)
{
Relation relation = await RepositoryResolver.GetRepository <IRelationRepository>().GetItemByIdAsync(relationId);
var transactions = await DbSet.Include(b => b.CategoryLinks).Include(b => b.Relation).Where(b => b.RelationID == relationId && b.ChangedCategories == false).ToListAsync();
foreach (Transaction transaction in transactions)
{
transaction.CategoryLinks.Clear();
foreach (var relLink in relation.CategoryLinks)
{
transaction.CategoryLinks.Add(new CategoryTransactionLink()
{
CategoryID = relLink.CategoryID,
Percentage = relLink.Percentage,
TransactionID = transaction.ID,
UserId = ServiceResolver.GetService <IUserProvider>().GetUserId()
});
}
await UpdateAsync(transaction.ID, transaction);
}
return(true);
}
public ServiceResponse <CommandInfo> Start(string command)
{
try
{
UserIsLoggedInOrDie();
CommandInfo info = new CommandInfo {
Command = command
};
IRepository repo = RepositoryResolver.GetRepository(HttpContext);
info = repo.Save(info);
Task <ProcessOutput> task = command.RunAsync();
task.ContinueWith((t) =>
{
Logger.AddEntry("Command completed: {0}", command);
info.StandardOut = t.Result.StandardOutput;
info.StandardError = t.Result.StandardError;
info = repo.Save(info);
});
Logger.AddEntry("Running command: {0}", command);
return(new ServiceResponse <CommandInfo>
{
Success = true,
Data = info
});
}
catch (Exception ex)
{
Logger.AddEntry("Error in CommandService: {0}", ex, ex.Message);
return(new ServiceResponse <CommandInfo>
{
Success = false,
Message = ex.Message
});
}
}
private void Save(object obj)
{
UpdateTaskNotifier = new NotifyTaskCompletion <Relation>(RepositoryResolver.GetRepository <IRelationRepository>().UpdateAsync(Relation.ID, Relation), OnRelationEdited);
}
public MainCategoryViewmodel(MainViewmodel mainViewmodel, CategoriesViewmodel categoryViewmodel)
: base(RepositoryResolver.GetRepository <IMainCategoryRepository>())
{
_mainViewmodel = mainViewmodel;
_categoryViewmodel = categoryViewmodel;
}
public TRepository GetRepository <TRepository>() where TRepository : IRepository
{
return(RepositoryResolver.GetRepository <TRepository>());
}