public IEnumerable <MonthlyCategory> TopTransactionsByAccountAndMonth(int accountId, int month)
{
using (var transactionRepository = repositoryFactory.CreateTransactionRepository())
using (var categoryRepository = repositoryFactory.CreateCategoryRepository())
{
var auhtenticatedUser = userSessionService.GetAuthenticatedUser();
if (month.Equals(default(int)))
{
month = DateTime.Now.Month;
}
var userCategories = categoryRepository.GetActiveUserCategories(auhtenticatedUser.Email);
var transactions = transactionRepository
.Where(x => x.AccountId.Equals(accountId) &&
x.Account.Measurable &&
x.Date.Month.Equals(month) &&
x.Date.Year.Equals(DateTime.Now.Year) &&
x.TransactionType == TransactionType.Expense &&
x.Category.Measurable);
var accountTransactions = transactions
.GroupBy(x => x.CategoryId)
.Select(x => new MonthlyCategory
{
Category = categoryMapper.ToModel(userCategories.First(uc => uc.Id.Equals(x.First().CategoryId))),
Price = x.Sum(d => d.Price)
});
return(accountTransactions);
}
}
public OperationResult CreateUser(string email, string language)
{
var userEntity = new User
{
Email = email,
};
using (var userRepository = repositoryFactory.CreateUserRepository())
using (var accountRepository = repositoryFactory.CreateAccountRepository())
using (var preferencesRepository = repositoryFactory.CreatePreferencesRepository())
using (var categoryRepository = repositoryFactory.CreateCategoryRepository())
{
userRepository.Add(userEntity);
accountRepository.Add(new Account
{
UserId = userEntity.Id,
Name = language.Contains("en") ? "Cash" : "Efectivo",
AccountType = Domain.AccountType.Cash,
CurrencyId = 1
});
accountRepository.Commit();
var categories = CategoryRepository.GetDefaultCategories().Select(x => new Category
{
Id = x.Id,
Name = x.Name,
Icon = x.Icon,
IsActive = true,
Measurable = true,
UserId = userEntity.Id
}).ToList();
categoryRepository.Add(categories);
categoryRepository.Commit();
preferencesRepository.Add(new Preferences
{
UserId = userEntity.Id,
Key = "PreferredCurrency",
Value = "USD",
});
preferencesRepository.Add(new Preferences
{
UserId = userEntity.Id,
Key = "Language",
Value = language,
});
preferencesRepository.Commit();
}
return(OperationResult.Succeed());
}
private AnswerStatus CreateCategories(BlogDto blogDTO, IUnitOfWork uow)
{
var categoryRepository = _repositoryFactory.CreateCategoryRepository(uow);
foreach (var categoryToAdd in blogDTO.BlogCategories)
{
categoryToAdd.RelatedTo = blogDTO;
AnswerStatus status = _categoryService.CreateCategory(categoryToAdd, categoryRepository);
if (status == AnswerStatus.Failed)
{
return(AnswerStatus.Failed);
}
}
return(AnswerStatus.Successfull);
}
public ExportableTransaction(IRepositoryFactory repositoryFactory,
IUserSessionService userService)
{
this.userService = userService;
categoryRepository = repositoryFactory.CreateCategoryRepository();
preferencesRepository = repositoryFactory.CreatePreferencesRepository();
}
public void Add(TransactionModel transaction)
{
Category category;
using (var transactionRepository = repositoryFactory.CreateTransactionRepository())
using (var accountRepository = repositoryFactory.CreateAccountRepository())
using (var categoryRepository = repositoryFactory.CreateCategoryRepository())
{
if (transaction.CategoryId.Equals(default) || categoryRepository.FirstOrDefault(x => x.Id.Equals(transaction.CategoryId)) == null)
public AnswerStatus CreateCategory(CategoryDto categoryDTO)
{
try
{
using (var uow = _unitOfWorkFactory.Create())
{
var categoryRepository = _repositoryFactory.CreateCategoryRepository(uow);
var result = CreateCategory(categoryDTO, categoryRepository);
if (result == AnswerStatus.Failed)
{
return(result);
}
uow.SaveChanges();
return(result);
}
}
catch (Exception exc)
{
_logger.Log(exc.ToString());
return(AnswerStatus.Failed);
}
}
public OperationResult Add(CategoryModel categoryModel)
{
using (var categoryRepository = repositoryFactory.CreateCategoryRepository())
{
var entity = categoryMapper.ToEntity(categoryModel);
var user = userService.GetAuthenticatedUser();
entity.UserId = user.Id;
categoryRepository.Add(entity);
categoryRepository.Commit();
return(OperationResult.Succeed());
}
}
public AnswerStatus CreatePost(PostDto postDTO)
{
using (var uow = _unitOfWorkFactory.Create())
{
try
{
var postToCreate = _postBuilder.CreatePost(postDTO.PostTitle, postDTO.PostContent, postDTO.CreationDate);
var blogRepository = _repositoryFactory.CreateBlogRepository(uow);
var postBlog = blogRepository.GetEntityById(postDTO.RelatedTo.Id);
_postBuilder.SetBlogRelatedTo(postToCreate, postBlog);
var postRepository = _repositoryFactory.CreatePostRepository(uow);
postRepository.CreateEntity(postToCreate);
var categoryRepository = _repositoryFactory.CreateCategoryRepository(uow);
if (postDTO.PostCategories != null)
{
foreach (var categoryDTO in postDTO.PostCategories)
{
var categoryToAdd = categoryRepository.GetEntityById(categoryDTO.Id);
if (categoryToAdd != null)
{
postRepository.AddCategoryToPost(postToCreate, categoryToAdd);
}
}
}
uow.SaveChanges();
return(AnswerStatus.Successfull);
}
catch (Exception exc)
{
_logger.Log(exc.ToString());
return(AnswerStatus.Failed);
}
}
}
