public async Task CreateTransactionByVacationAsync(VacationDto vacation, ClaimsPrincipal user)
        {
            var balance = (int)vacation.EndVocationDate.Subtract(vacation.StartVocationDate).TotalDays;

            if (balance <= 0)
            {
                throw new ArgumentOutOfRangeException("Start Date >= End Date");
            }

            var transacrion = new Transaction()
            {
                TransactionId     = new Guid(),
                TransactionTypeId = _context.TransactionType.FirstOrDefault(t => t.Name == "ByVacation").TransactionTypeId,
                EmployeeId        = vacation.EmployeeId,
                Days            = -balance,
                Comment         = vacation.TransactionComment,
                AuthorId        = (await _usersService.GetUserAsync(user)).EmployeeId,
                VacationId      = vacation.VacationId,
                TransactionDate = DateTime.UtcNow
            };

            var employee = _context.Employee.Find(vacation.EmployeeId);

            employee.Balance += transacrion.Days;

            await _context.Transaction.AddAsync(transacrion);

            _context.Employee.Update(employee);

            await _context.SaveChangesAsync();
        }
Пример #2
0
        public async Task PutAsync(VacationDto vacationDto, ClaimsPrincipal user)
        {
            if (vacationDto.VacationStatusId == null)
            {
                throw new ArgumentException("");
            }

            var vacation = new Vacation
            {
                VacationId        = vacationDto.VacationId,
                StartVocationDate = vacationDto.StartVocationDate,
                EndVocationDate   = vacationDto.EndVocationDate,
                VacationStatusId  = vacationDto.VacationStatusId ?? new Guid(),
                VacationTypesId   = vacationDto.VacationTypesId,
                Comment           = vacationDto.Comment,
                EmployeeId        = vacationDto.EmployeeId,
            };

            using (var scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
            {
                _context.Vacation.Update(vacation);

                if (vacation.VacationStatusId == _vacationStatusService.Get().FirstOrDefault(vs => vs.Name == "Approved").VacationStatusId)
                {
                    await _transactionService.CreateTransactionByVacationAsync(vacationDto, user);
                }

                await _context.SaveChangesAsync();

                scope.Complete();
            }

            await VacationStatusSendEmail(vacationDto, (await _context.Employee.FirstOrDefaultAsync(e => e.EmployeeId == vacation.EmployeeId)).WorkEmail);
        }
Пример #3
0
        public async Task PutAsync(VacationDto vacationDto, ClaimsPrincipal user)
        {
            if (vacationDto.VacationStatusId == null)
            {
                throw new ArgumentException("");
            }

            var vacation = new Vacation
            {
                VacationId        = vacationDto.VacationId,
                StartVocationDate = vacationDto.StartVocationDate,
                EndVocationDate   = vacationDto.EndVocationDate,
                VacationStatusId  = vacationDto.VacationStatusId ?? new Guid(),
                VacationTypesId   = vacationDto.VacationTypesId,
                Comment           = vacationDto.Comment,
                EmployeeId        = vacationDto.EmployeeId,
            };

            using (var scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
            {
                _context.Vacation.Update(vacation);

                if (vacation.VacationStatusId == _vacationStatusService.Get().FirstOrDefault(vs => vs.Name == "Approved").VacationStatusId)
                {
                    await _transactionService.CreateTransactionByVacationAsync(vacationDto, user);
                }

                await _context.SaveChangesAsync();

                scope.Complete();
            }

            var workEmail = (await _context.Employee
                             .Include(t => t.Team.TeamLead)
                             .Select(
                                 e => new
            {
                e.Team.TeamLead.WorkEmail,
                e.EmployeeId
            }
                                 ).FirstOrDefaultAsync(e => e.EmployeeId == vacationDto.EmployeeId)).WorkEmail;

            if (workEmail == null)
            {
                foreach (var item in await _userManager.GetUsersInRoleAsync("Admin"))
                {
                    await VacationRequestSendEmail(vacationDto, item.Email);
                }
            }
            else
            {
                await VacationRequestSendEmail(vacationDto, workEmail);
            }
        }
        public async Task PutAsync(EmployeeDto employeeDto, ClaimsPrincipal admin)
        {
            var employee = await _context.Employee.FindAsync(employeeDto.EmployeeId);

            if (employee == null)
            {
                throw new InvalidOperationException();
            }

            var user = await _usersService.FindByEmailAsync(employee.WorkEmail);

            if (user == null)
            {
                throw new InvalidOperationException();
            }

            _context.Entry(employee).State = EntityState.Detached;

            var newBalance = (employeeDto.Balance ?? CulcBalance()) - employee.Balance;

            var newEmployee = _mapper.Map <EmployeeDto, Employee>(employeeDto);

            newEmployee.Balance = employeeDto.Balance ?? CulcBalance();

            newEmployee.ImgUrl = await _imagesService.GetUrlAsync(employeeDto.ImgUrl);

            using (var scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
            {
                _context.Employee.Update(newEmployee);

                user.UserName = employeeDto.WorkEmail;

                user.Email = employeeDto.WorkEmail;

                await _transactionService.CreateTransactionByAdminAsync(newEmployee.EmployeeId, newBalance, admin);

                await _usersService.UpdateUser(user);

                await _usersService.UpdateUserRole(user, employeeDto.RoleId);

                await _context.SaveChangesAsync();

                scope.Complete();
            }
        }