public void Can_Start_And_Finish_Operations()
{
var repo = new OperationRepository(Context);
using (var transaction = Context.Database.BeginTransaction())
{
var op1 = repo.Start("TEST", null);
var op2 = repo.GetCurrent();
var op3 = repo.GetCurrent();
var ops = new List <Operation>()
{
op1, op2, op3
};
Assert.AreEqual(1, ops.Select(x => x.Id).Distinct().Count());
repo.Stop(op1);
var op4 = repo.GetCurrent();
Assert.IsNull(op4);
transaction.Commit();
}
var op5 = repo.GetCurrent();
Assert.IsNull(op5);
}
private async void AddOperation(Operation operation)
{
OperationRepository opRep = new OperationRepository(null);
await opRep.AddItemAsync(operation, 1);
await opRep.AddItemAsync(operation, 2);
}
public PermissionDtoContainer GetCurrentRolePermissions(int roleId)
{
PermissionDtoContainer container = new PermissionDtoContainer();
var opRes = this.Repository.Context.PermissionToRoles.Where(it => it.RoleId == roleId).Select(x => new { permission = x.Permission, operation = x.Permission.Operation, resource = x.Permission.Securityresource, AccessType = x.PermisssionAccess }).ToList();
foreach (var item in opRes)
{
var permission = PermissionRepository.GetDto(item.permission);
var operatoin = item.operation;
var resource = item.resource;
permission.OperationDto = OperationRepository.GetDto(operatoin);
permission.SecurityResourceDto = SecurityResourceRepository.GetDto(resource);
permission.SecurityResourceDto.Checked = true;
container.PermissionDtoList.Add(permission);
// container.SecurityResourceDtoList.Add(permission.SecurityResourceDto);
permission.SecurityResourceDto.Checked = true;
if (item.AccessType == 0)
{
permission.AccessType = Common.Enums.AccessType.None;
}
if (item.AccessType == -1)
{
permission.AccessType = Common.Enums.AccessType.Deny;
}
if (item.AccessType == 1)
{
permission.AccessType = Common.Enums.AccessType.Access;
permission.OperationDto.Checked = true;
AddResources(permission.SecurityResourceDto, container.SecurityResourceDtoList);
}
}
return(container);
}
public void GetOperationsByAccount_SomeOperationsFound()
{
IOperationRepository operationRepository = new OperationRepository(NhibernateHelper.SessionFactory);
Repository repository = new Repository(NhibernateHelper.SessionFactory);
Customer thirdParty1 = new Customer {
Code = "tjdsklfs", Email = "*****@*****.**", FirstName = "Olivier", LastName = "Roux", Password = "******", PasswordSalt = "sss"
};
Account account1 = new Account {
Balance = 201, BalanceDate = DateTime.Now, Number = "dsf1", Iban = "1242255"
};
Account account2 = new Account {
Balance = 201, BalanceDate = DateTime.Now, Number = "dsf1", Iban = "1242255"
};
Operation operation1 = new Operation {
Account = account1, Amount = 200, Direction = Direction.Credit, Motif = "blabla", TransactionCode = "1245"
};
Operation operation2 = new Operation {
Account = account1, Amount = 654, Direction = Direction.Debit, Motif = "blibli", TransactionCode = "1245"
};
using (NhibernateHelper.SessionFactory.GetCurrentSession().BeginTransaction())
{
repository.Save(thirdParty1);
repository.Save(account1);
repository.Save(account2);
repository.Save(operation1);
repository.Save(operation2);
repository.Flush();
IList <Operation> operations = operationRepository.GetOperationsByAccount(account1.Id);
Assert.AreEqual(2, operations.Count);
}
}
public StornoController(
CriteriaRepository <WorkerCardContent> workerCardContentRepository,
CriteriaRepository <Worker> workerRepository,
CriteriaRepository <WorkerWorkplace> workerWorkplaceRepository,
CriteriaRepository <Storage> storageRepository,
StorageNameRepository storageNameRepository,
CriteriaRepository <OperType> operTypeRepository,
RemainRepository remainRepository,
OperationRepository operationRepository,
CriteriaRepository <OperationSimple> operationSimpleRepository,
CriteriaRepository <Config> configRepository,
CriteriaRepository <MatPersonCardContent> matPersonCardContentRepository,
CriteriaRepository <MatPersonCardHead> matPersonCardHeadRepository
)
{
Check.Require(operationRepository != null, "operationRepository may not be null");
this.workerCardContentRepository = workerCardContentRepository;
this.workerRepository = workerRepository;
this.workerWorkplaceRepository = workerWorkplaceRepository;
this.storageRepository = storageRepository;
this.storageNameRepository = storageNameRepository;
this.operTypeRepository = operTypeRepository;
this.operationRepository = operationRepository;
this.operationSimpleRepository = operationSimpleRepository;
this.remainRepository = remainRepository;
this.configRepository = configRepository;
this.matPersonCardContentRepository = matPersonCardContentRepository;
this.matPersonCardHeadRepository = matPersonCardHeadRepository;
}
protected UnitOfWork(ApplicationDbContext context)
{
_context = context;
TimedTaskRepository = new TimedTaskRepository(context);
OperationRepository = new OperationRepository(context);
FileRepository = new FileRepository(context);
}
public WorkerCardReturnController(CriteriaRepository <WorkerCardHead> workerCardRepository,
CriteriaRepository <WorkerCardContent> workerCardContentRepository,
CriteriaRepository <NormaOrganization> normaOrganizationRepository,
CriteriaRepository <Worker> workerRepository,
CriteriaRepository <NormaContent> normaContentRepository,
CriteriaRepository <WorkerWorkplace> workerWorkplaceRepository,
CriteriaRepository <Storage> storageRepository,
CriteriaRepository <StorageName> storageNameRepository,
CriteriaRepository <OperType> operTypeRepository,
CriteriaRepository <Organization> organizationRepository,
OperationRepository operationRepository,
CriteriaRepository <Motiv> motivRepository,
CriteriaRepository <Config> configRepository,
RemainRepository remainsRepository,
CriteriaRepository <NomBodyPartSize> nomBodyPartSizeRepository)
{
Check.Require(workerCardRepository != null, "workerWorkplaceRepository may not be null");
this.workerCardContentRepository = workerCardContentRepository;
this.workerCardRepository = workerCardRepository;
this.normaOrganizationRepository = normaOrganizationRepository;
this.workerRepository = workerRepository;
this.normaContentRepository = normaContentRepository;
this.workerWorkplaceRepository = workerWorkplaceRepository;
this.storageRepository = storageRepository;
this.storageNameRepository = storageNameRepository;
this.operTypeRepository = operTypeRepository;
this.organizationRepository = organizationRepository;
this.operationRepository = operationRepository;
this.motivRepository = motivRepository;
this.configRepository = configRepository;
this.remainsRepository = remainsRepository;
this.nomBodyPartSizeRepository = nomBodyPartSizeRepository;
}
public DoctorService()
{
doctorRepository = new DoctorRepository(path);
patientsRepository = new PatientsRepository(path2);
operationRepository = new OperationRepository(path3);
appointmentRepository = new AppointmentRepository(path4);
employeesScheduleRepository = new EmployeesScheduleRepository(path5);
}
public CalcController()
{
var connString = @"Data Source=(LocalDB)\MSSQLLocalDB;AttachDbFilename=Z:\it\ITUniver.TeleCalc.Web\App_Data\TeleCalcDB.mdf;Integrated Security=True";
Calc = new Calc();
HistoryRepository = new HistoryRepository(connString);
OperationRepository = new OperationRepository(connString);
}
public FinancialCoefficientsVM(User _user)
{
User = _user;
repository = new OperationRepository(_user);
DateFinish = DateTime.Now;
DateStart = DateFinish.Subtract(new TimeSpan(30, 0, 0, 0));
ChangedDatesAsync();
}
public AnaliticsVM(User _user)
{
Title = "Список транзакций";
Operations = new ObservableCollection <Operation>();
User = _user;
opRepository = new OperationRepository(_user);
LoadItemsCommand = new Command(async() => await ExecuteLoadItemsCommand());
Search = "";
DateFinish = DateTime.Now;
DateStart = DateFinish.Subtract(new TimeSpan(30, 0, 0, 0));
}
public static void AddOperation(PetData pet, DateTime date, UserData user)
{
OperationRepository opRep = new OperationRepository();
opRep.Create(new Operation
{
PetId = pet.Id,
OperationDate = date.Date,
UserId = user.Id
});
}
public static Operation GetByCode(int code)
{
try
{
return(OperationRepository.GetByCode(code));
}
catch (Exception ex)
{
throw ex;
}
}
public DepositHandler(TimeSpan period, ILogFactory logFactory, DepositWalletRepository depositWallets, OperationRepository operations, AssetRepository assets,
StateRepository <TState> state, IBlockchainJob <TState> job, IChaosKitty chaosKitty = null) : base(period, logFactory, nameof(DepositHandler <TState>))
{
_depositWallets = depositWallets;
_operations = operations;
_assets = assets;
_state = state;
_job = job;
_chaosKitty = chaosKitty;
_log = logFactory.CreateLog(this);
}
public OperationVM(User _user, object filter = null)
{
User = _user;
opRepository = new OperationRepository(_user);
Filter = filter;
if (filter != null)
{
if (filter is Account accountForFilter)
{
Title = accountForFilter.Title;
}
else
{
if (filter is Category categoryForFilter)
{
Title = categoryForFilter.Title;
}
else
{
Title = "Лента";
}
}
}
else
{
Title = "Лента";
}
Operations = new ObservableCollection <Operation>();
if (filter != null)
{
if (filter is Category categoryForFilter)
{
IsHideBalanceField = true;
}
else
{
IsHideBalanceField = false;
}
}
LoadItemsCommand = new Command(async() => await ExecuteLoadItemsCommand(filter));
MessagingCenter.Subscribe <NewOperationPage, Operation>(this, "AddOperation", (obj, item) => {
Operations.Insert(0, item as Operation);
});
//MessagingCenter.Subscribe<NewOperationPage, Operation>(this, "UpdateOperation", (obj, item) => {
// var newItem = item as Operation;
// var oldItem = Operations[Operations.IndexOf(Operations.FirstOrDefault(i => i.Id == newItem.Id))];
// //await opRepository.UpdateItemAsync(newItem);
//});
}
/// <summary>
/// 校验创建操作
/// </summary>
/// <param name="entity">实体</param>
private async Task ValidateCreateAsync(Operation entity)
{
entity.CheckNull(nameof(entity));
if (!await OperationRepository.CanCreateAsync(entity))
{
ThrowUriRepeatException(entity);
}
if (!await ModuleRepository.ExistsAsync(entity.ModuleId))
{
throw new Warning("模块不存在");
}
}
/// <summary>
/// 获取所有菜单
/// </summary>
/// <param name="applicationId">应用程序标识</param>
/// <param name="roleId">角色标识</param>
public async Task <List <SelectModuleResponse> > GetAllMenusAsync(Guid applicationId, Guid roleId)
{
var modules = await ModuleRepository.GetModulesAsync(applicationId);
var operations = await OperationRepository.GetAllOperationsAsync(applicationId);
var permissions = await PermissionRepository.GetResourceIdsAsync(applicationId, roleId, false);
var result = new SelectMenuResult(modules, operations, permissions);
return(result.GetResult());
}
/// <summary>
/// 修改操作
/// </summary>
/// <param name="request">请求</param>
public async Task UpdateAsync(UpdateOperationRequest request)
{
var operation = await OperationRepository.FindAsync(request.Id.ToGuid());
request.MapTo(operation);
await ValidateUpdateAsync(operation);
operation.InitPinYin();
await OperationRepository.UpdateAsync(operation);
await UnitOfWork.CommitAsync();
}
public UnitOfWork(ApplicationDbContext applicationDbContext)
{
_context = applicationDbContext;
Operations = new OperationRepository(applicationDbContext);
OperationTypes = new OperationTypeRepository(applicationDbContext);
Scores = new ScoreRepository(applicationDbContext);
PaymentTypes = new PaymentTypeRepository(applicationDbContext);
Projects = new ProjectRepository(applicationDbContext);
Users = new UserRepository(applicationDbContext);
CounterParties = new CounterPartyRepository(applicationDbContext);
Transactions = new TransactionRepository(applicationDbContext);
}
public TransactionsController(
IBlockchainApi api,
OperationRepository operations,
AssetRepository assets,
DepositWalletRepository depositWallets,
IChaosKitty chaosKitty = null)
{
_api = api;
_operations = operations;
_assets = assets;
_depositWallets = depositWallets;
_chaosKitty = chaosKitty;
}
public MoveStorageOutController(CriteriaRepository <Storage> storageRepository,
StorageNameRepository storageNameRepository,
CriteriaRepository <OperType> operTypeRepository,
CriteriaRepository <Organization> organizationRepository,
OperationRepository operationRepository)
{
Check.Require(storageRepository != null, "storageRepository may not be null");
this.storageRepository = storageRepository;
this.operTypeRepository = operTypeRepository;
this.organizationRepository = organizationRepository;
this.operationRepository = operationRepository;
this.storageNameRepository = storageNameRepository;
}
public OperationsController(OperationRepository operationRepository,
StorageNameRepository storageNameRepository,
NomenclatureRepository nomenRepository,
CriteriaRepository <OperationSimple> operationSimpleRepository,
CriteriaRepository <OperType> operationTypeRepository)
{
Check.Require(operationRepository != null, "operationRepository may not be null");
this.operationRepository = operationRepository;
this.operationTypeRepository = operationTypeRepository;
this.operationSimpleRepository = operationSimpleRepository;
this.nomenRepository = nomenRepository;
this.storageNameRepository = storageNameRepository;
}
public List <OperationDto> UserOperations(Common.DTO.UserDto user, Common.DTO.SecurityResourceDto resource)
{
List <OperationDto> lst = new List <OperationDto>();
var operations = this.Repository.Context.PermissionToUsers.Where(it => it.UserId == user.UserId && it.Permission.ResourceId == resource.SecurityResourceId).Select(it => it.Permission.Operation).ToList();
foreach (var operation in operations)
{
var dto = OperationRepository.GetDto(operation);
lst.Add(dto);
}
return(lst);
}
/// <summary>
/// 创建操作
/// </summary>
/// <param name="request">请求</param>
public async Task <Guid> CreateAsync(CreateOperationRequest request)
{
var operation = request.ToOperation();
await ValidateCreateAsync(operation);
operation.Init();
await OperationRepository.AddAsync(operation);
await UnitOfWork.CommitAsync();
return(operation.Id);
}
public List <OperationDto> GroupOperations(Common.DTO.SecurityGroupDto group, Common.DTO.SecurityResourceDto resource)
{
List <OperationDto> lst = new List <OperationDto>();
var roles = this.Repository.Context.RoleToGroups.Where(it => it.GroupId == group.SecurityGroupId).Select(it => it.Role).ToList();
foreach (var role in roles)
{
var operations = this.Repository.Context.PermissionToRoles.Where(it => it.RoleId == role.RoleId && it.Permission.ResourceId == resource.SecurityResourceId).Select(it => it.Permission.Operation);
var operationDtos = OperationRepository.GetDtos(operations);
lst.AddRange(operationDtos);
}
return(lst);
}
public OperationController(FinalProjectContext context)
{
_context = context;
_repo = new OperationRepository(_context);
if (_context.Operations.Count() == 0)
{
TimeSpan span = new TimeSpan(0, 0, 0, 30, 50);
_context.Operations.Add(new Operation {
Name = "Method Test1", ExecutionDate = DateTime.Now, ExecutionTime = span
});
_context.SaveChanges();
}
}
/// <summary>
/// 删除操作
/// </summary>
/// <param name="ids">用逗号分隔的Id列表。范例："1,2"</param>
public async Task DeleteAsync(string ids)
{
if (string.IsNullOrWhiteSpace(ids))
{
return;
}
var entities = await OperationRepository.FindByIdsAsync(ids);
if (entities?.Count == 0)
{
return;
}
await OperationRepository.RemoveAsync(entities);
await UnitOfWork.CommitAsync();
}
public OperationDetailVM(Operation newOperation, User _user, OperationRepository _opRepository = null)
{
Title = newOperation?.Date.ToString();
opRepository = _opRepository;
User = _user;
accountRep = new AccountRepository(User);
Destinations = new List <ImageItem>();
if (newOperation != null && !String.IsNullOrEmpty(newOperation.Images))
{
foreach (var im in newOperation.StringToPaths())
{
Destinations.Add(im);
}
}
#region Get Properties
Accounts = accountRep.GetAccounts();
Purposes = accountRep.GetPurposes();
CategoryRepository categoryRep = new CategoryRepository(User);
Categories = categoryRep.GetItems();
CurrencyRepository currencyRep = new CurrencyRepository();
Currencies = currencyRep.GetItems();
UserRepository userRep = new UserRepository();
Users = userRep.GetItems();
Accounts.Insert(0, new Account("Выбрать", 0, 0, 0, null));
Categories.Insert(0, new Category("Выбрать", null));
Purposes.Insert(0, new Account("Выбрать", 0, 0, 0, null));
ListForPickerType = new List <string> {
"Приход", "Расход", "Перевод"
};
#endregion
if (newOperation == null)
{
Operation = new Operation(DateTime.Now, 0, 2, "", null, null, null, null, Users[0]);
}
else
{
Operation = newOperation;
adding = false;
}
}
/// <summary>
/// 获取角色菜单
/// </summary>
/// <param name="applicationId">应用程序标识</param>
/// <param name="roleId">角色标识</param>
public async Task <List <SelectModuleResponse> > GetRoleMenusAsync(Guid applicationId, Guid roleId)
{
var role = await RoleRepository.FindAsync(roleId);
var roleIds = new List <Guid>()
{
roleId, role.ParentId.SafeValue()
};
var modules = await ModuleRepository.GetModulesAsync(applicationId, roleIds);
var operations = await OperationRepository.GetOperationsAsync(applicationId, roleIds);
var permissions = await PermissionRepository.GetResourceIdsAsync(applicationId, roleId, false);
var result = new SelectMenuResult(modules, operations, permissions);
return(result.GetResult());
}
public static Operation SaveOrUpdate(Operation pallet)
{
try
{
if (pallet.Code == 0)
{
new Exception("El código de estación no puede ser 0");
}
OperationRepository.SaveOrUpdate(pallet);
}
catch (Exception ex)
{
throw ex;
}
return(pallet);
}
public MainRepository(AppContext context)
{
_context = context;
Calls = new CallRepository(_context);
Users = new UserRepository(_context);
Locations = new LocationRepository(_context);
Groups = new GroupRepository(_context);
Operations = new OperationRepository(_context);
Roles = new RoleRepository(_context);
Debits = new DebitRepository(_context);
PenaltyTypes = new PenaltyTypeRepository(_context);
Employees = new EmployeeRepository(_context);
Extras = new ExtraRepository(_context);
PayRolls = new PayRollRepository(_context);
Salaries = new SalaryRepository(_context);
DebitTypes = new DebitTypeRepository(_context);
Penalties = new PenaltyRepository(_context);
DebitPayments = new DebitPaymentRepository(_context);
Administrators = new AdministratorRepository(_context);
Savings = new SavingRepository(_context);
Vacations = new VacationRepository(_context);
RoleOperations = new RoleOperationRepository(_context);
}
