public async Task DoWorkAsync(CancellationToken token)
{
while (true)
{
try
{
printService.ProcessDocuments();
printService.DeleteExpiredDocument();
printService.ArchiveReports();
}
catch (Exception e)
{
using (EventLog eventLog = new EventLog("Application"))
{
eventLog.Source = _serviceName;
eventLog.WriteEntry("PrintService Exception " + e.Message, EventLogEntryType.Error, 101);
serviceResult.Error(e.ToString());
serviceResult.EmailResults(new List <String> {
_toEmailAddress
}, "PrintService Exception " + e.Message);
}
}
await Task.Delay(TimeSpan.FromMinutes(1), token);
}
}
public async Task <IServiceResult <InstituteViewModel> > Update(
int id,
InstituteRegistration newData)
{
var institute = _context.Institutes.FirstOrDefault(i => i.Id == id);
if (institute == null)
{
return(ServiceResult <InstituteViewModel> .Error(
$"Institute with id {id} does not exist"));
}
if (IsNameTakenByAnotherInstitute(institute.Id, newData.Name))
{
return(ServiceResult <InstituteViewModel> .Error(
$"Institute name {newData.Name} already exists"
));
}
institute = _mapper.Map(newData, institute);
_context.Institutes.Update(institute);
await _context.SaveChangesAsync();
var instituteViewModel = _mapper.Map <InstituteViewModel>(institute);
return(ServiceResult <InstituteViewModel> .Success(instituteViewModel));
}
public async Task <ServiceResult <ProjectModel> > EditProject(EditProjectModel model, string userId)
{
var projectRes = await GetEntityById(model.Id);
if (projectRes.IsError)
{
return(ServiceResult <ProjectModel> .NotFound("Project not found"));
}
if (!projectRes.Value.Members.Any(m => m.MemberId == userId && m.Role == ProjectRoleEnum.Owner && m.DeletedByUserId == null))
{
return(ServiceResult <ProjectModel> .Error("You are cant moderate it"));
}
projectRes.Value.InjectFrom(model);
projectRes.Value.Status = model.Status ?? projectRes.Value.Status;
projectRes.Value.MarkUpdated(userId);
_dbContext.Projects.Update(projectRes.Value);
var count = await _dbContext.SaveChangesAsync();
return(count != 1
? ServiceResult <ProjectModel> .Error("Проект не был обновлен")
: ServiceResult <ProjectModel> .Ok(GetModelFromEntity(projectRes.Value)));
}
public async Task <ServiceResult <PagedList <IssueModel> > > GetByVersionId(string versionId, string userId, int pageSize = 25, int page = 1)
{
var version = await _dbContext.Versions
.FirstOrDefaultAsync(p => p.Id == versionId);
if (version == null)
{
return(ServiceResult <PagedList <IssueModel> > .NotFound());
}
var isMember = await IsMember(version.ProjectId, userId);
if (!isMember)
{
return(ServiceResult <PagedList <IssueModel> > .Error(ProjectsConstants.NotAMember));
}
var query = _dbContext.Issues
.Where(p => p.VersionId == versionId && p.DeletedByUserId == null);
var count = await query.CountAsync();
var issues = (await query
.Page(pageSize, page)
.ToListAsync())
.Select(GetModelFromEntity)
.ToPagedList(count, pageSize, page);
return(ServiceResult <PagedList <IssueModel> > .Ok(issues));
}
public async Task <ServiceResult <IssueModel> > Update(IssueEditModel model, string userId)
{
var issueRes = await GetEntityById(model.Id);
if (issueRes.IsError)
{
return(ServiceResult <IssueModel> .NotFound("Issue not found"));
}
var isMember = await IsMember(issueRes.Value.ProjectId, userId);
if (!isMember)
{
return(ServiceResult <IssueModel> .Error(ProjectsConstants.NotAMember));
}
issueRes.Value.InjectFrom(model);
issueRes.Value.MarkUpdated(userId);
_dbContext.Issues.Update(issueRes.Value);
var count = await _dbContext.SaveChangesAsync();
return(count != 1
? ServiceResult <IssueModel> .Error("Something went wrong")
: ServiceResult <IssueModel> .Ok((IssueModel) new IssueModel().InjectFrom(issueRes.Value)));
}
public ServiceResult <BookInfo> GetBook(int Id)
{
//string query = "SELECT * FROM Department WHERE DepartmentID = {0}";
//var department = await _db.Books
// .FromSql(query, id)
// .Include(d => d.Administrator)
// .AsNoTracking()
// .SingleOrDefaultAsync();
//如果正在跟踪大量实体，并且这些方法之一在循环中多次调用，通过使用ChangeTracker.AutoDetectChangesEnabled属性暂时关闭自动脏值检测，能够显著改进性能。
//_context.ChangeTracker.AutoDetectChangesEnabled = false;
var query = _db.Books.FirstOrDefaultAsync(q => q.Id == Id);
if (query.IsCompleted && query.Result == null)
{
return(ServiceResult <BookInfo> .Error("数据不存在"));
}
else
{
var entity = new BookInfo()
{
AminId = query.Result.AminId,
Author = query.Result.Author,
CoverImage = query.Result.CoverImage,
Name = query.Result.Name
};
return(ServiceResult <BookInfo> .Success(entity));
}
}
public async Task <IServiceResult <CourseViewModel> > Create(CourseRegistration registration)
{
var faculty = await _context
.Faculties
.Include(f => f.Courses)
.FirstOrDefaultAsync(f => f.Id == registration.FacultyId);
if (faculty == null)
{
return(ServiceResult <CourseViewModel> .Error(
$"Faculty with id {registration.FacultyId} does not exist"
));
}
if (IsCourseNameOnFacultyTaken(registration.Name, faculty))
{
return(ServiceResult <CourseViewModel> .Error(
$"Faculty with id {faculty.Id} already has a course with name {registration.Name}"
));
}
var course = _mapper.Map <Course>(registration);
await _context.Courses.AddAsync(course);
await _context.SaveChangesAsync();
var courseViewModel = _mapper.Map <CourseViewModel>(course);
return(ServiceResult <CourseViewModel> .Success(courseViewModel));
}
public async Task <IServiceResult <FileDescription> > GetCsvFileDescription(int id)
{
var proposal = await _context.Proposals
.Include(p => p.Course.Faculty)
.Include(p => p.Promoter.Institute)
.FirstOrDefaultAsync(p => p.Id == id);
if (proposal == null)
{
return(ServiceResult <FileDescription> .Error(
$"Proposal with id {id} does not exist"));
}
var proposalCsvRecord = _mapper.Map <ProposalCsvRecord>(proposal);
var records = new ProposalCsvRecord[] { proposalCsvRecord };
var csvStringResult = _csvCreator.CreateCsvStringFrom <ProposalCsvRecord>(records);
if (!csvStringResult.Successful())
{
return(ServiceResult <FileDescription> .Error(csvStringResult.GetAggregatedErrors()));
}
var csvString = csvStringResult.Body();
var bytes = Encoding.UTF8.GetBytes(csvString);
var fileName = $"proposal-{proposal.Id}.csv";
var fileDescription = new FileDescription {
Name = fileName,
Bytes = bytes
};
return(ServiceResult <FileDescription> .Success(fileDescription));
}
public async Task <ServiceResult> AddAsync(AddUserContract user)
{
ServiceResult result = new ServiceResult();
try
{
var check = await userRepository.GetCountAsync(userRepository.GetTable.Where(d => d.UserID.Equals(user.UserID)).AsQueryable());
if (check == 0)
{
tUser data = new tUser
{
UserID = Guid.Parse(user.UserID.ToString()),
Password = HelperMethod.encrypt(user.Password),
FirstName = user.FirstName,
LastName = user.LastName,
CreateDate = DateTime.Now,
UpdateDate = DateTime.Now
};
var save = await userRepository.AddAsync(data);
result = save.status;
}
else
{
result.BadRequest("REGISTERED_ALREADY");
}
return(result);
}
catch (Exception ex)
{
result.Error("ERROR", ex.Message);
}
return(result);
}
/// <summary>
/// Handle 'around' advice for testing services
/// </summary>
public object Invoke(IMethodInvocation invocation)
{
object returnValue = null;
_repository = ServiceTestBase.GetRepository();
DomainRegistry.Repository = _repository;
DomainRegistry.Library = null;
try
{
returnValue = invocation.Proceed();
_repository.Flush();
_repository.Clear();
}
catch (Exception e)
{
returnValue = ServiceResult.Error(invocation.Method.ReturnType, e);
}
_visitedObjects.Clear();
VerifyNoRealDomainObjects(returnValue);
return(returnValue);
}
public async Task <ServiceResult <int> > AddUser(string groupCode, User user)
{
var group = groupsRepository.Get(groupCode);
if (group is null)
{
return(ServiceResult <int> .Error(404, "Group does not exist"));
}
if (groupUsersRepository.GetCount(group.Id, user.Id) != 0)
{
return(ServiceResult <int> .Error(400, "User is already in group"));
}
var groupUser = new GroupUser()
{
GroupId = group.Id,
UserId = user.Id
};
var result = await groupUsersRepository.CreateAsync(groupUser);
if (result is null)
{
return(ServiceResult <int> .Error(500, "Error adding user to group"));
}
await actionService.CreateAsync(group.Id, user.Id, "Joined", $"{user.UserName} has joined the group");
return(ServiceResult <int> .Success((IViewModel <int>) null));
}
public IActionResult ApiCreate(LocationCreateModel model)
{
if (!ModelState.IsValid)
{
return(Ok(ServiceResult.Error(ModelState)));
}
var location = new Location
{
Title = model.Title,
Members = new List <LocationMember>()
{
new LocationMember()
{
FullName = model.ManagerFullName,
Type = MemberType.Manager,
PhoneNumbers = JsonConvert.SerializeObject(model.ManagerPhoneNumbers)
}
}
};
var result = _repo.Create(location);
return(Ok(result));
}
public async Task <ServiceResult <int> > UpdateAsync(ClaimsPrincipal user, int groupId, int categoryId, CategoryRequestModel category)
{
var group = groupsRepository.Get(groupId);
if (group is null)
{
return(ServiceResult <int> .Error(404, "Group was not found"));
}
var authorizationResult = await authorizationService.AuthorizeAsync(user, group, GroupOperations.Write);
if (!authorizationResult.Succeeded)
{
return(ServiceResult <int> .Error(401, "Unauthorized"));
}
var categoryEntity = categoriesRepository.Get(categoryId);
if (categoryEntity is null || categoryEntity.GroupId != groupId)
{
return(ServiceResult <int> .Error(404, "Category was not found"));
}
categoryEntity.Name = category.Name;
categoryEntity.Description = category.Description;
var result = await categoriesRepository.UpdateAsync(categoryEntity);
if (result is null)
{
return(ServiceResult <int> .Error(500, "Could not update category"));
}
return(ServiceResult <int> .Success(CategoryViewModel.FromModel(result)));
}
public async Task <ServiceResult <int> > DeleteAsync(ClaimsPrincipal user, int groupId, int categoryId)
{
var group = groupsRepository.Get(groupId);
if (group is null)
{
return(ServiceResult <int> .Error(404, "Group was not found"));
}
var authorizationResult = await authorizationService.AuthorizeAsync(user, group, GroupOperations.Write);
if (!authorizationResult.Succeeded)
{
return(ServiceResult <int> .Error(401, "Unauthorized"));
}
var category = categoriesRepository.Get(categoryId);
if (category is null || category.GroupId != groupId)
{
return(ServiceResult <int> .Error(404, "Category was not found"));
}
category.Deleted = true;
var result = await categoriesRepository.UpdateAsync(category);
if (result is null)
{
return(ServiceResult <int> .Error(500, "Error deleting category"));
}
return(ServiceResult <int> .Success(CategoryViewModel.FromModel(result)));
}
public async Task <IServiceResult <UserSecurityStamp> > Login(string email, string password)
{
var user = await _userManager.FindByEmailAsync(email);
if (user == null)
{
return(ServiceResult <UserSecurityStamp> .Error("User not found"));
}
var canSignIn = await _signInManager.CanSignInAsync(user);
if (canSignIn)
{
var result =
await _signInManager.PasswordSignInAsync(email, password, true, false);
if (result.Succeeded)
{
var roles = await _userManager.GetRolesAsync(user);
string token = _tokenGenerator.GenerateTokenFor(user, roles);
user.SecurityStamp = token;
return(ServiceResult <UserSecurityStamp> .Success(new UserSecurityStamp
{
Email = user.Email,
SecurityStamp = user.SecurityStamp
}));
}
}
return(ServiceResult <UserSecurityStamp> .Error("User cannot sign in"));
}
public async Task <IServiceResult <FacultyViewModel> > Update(
int id,
FacultyRegistration newData)
{
var faculty = _context.Faculties.FirstOrDefault(f => f.Id == id);
if (faculty == null)
{
return(ServiceResult <FacultyViewModel> .Error(
$"Faculty with id {id} does not exist"));
}
if (FacultyNameTaken(faculty.Id, newData.Name))
{
return(ServiceResult <FacultyViewModel> .Error(
$"Faculty name {newData.Name} already exists"
));
}
faculty = _mapper.Map(newData, faculty);
_context.Faculties.Update(faculty);
await _context.SaveChangesAsync();
var facultyViewModel = _mapper.Map <FacultyViewModel>(faculty);
return(ServiceResult <FacultyViewModel> .Success(facultyViewModel));
}
public async Task <IServiceResult <FileDescription> > GetDiplomaCard(int id)
{
var proposal = await _context.Proposals
.Include(p => p.Course.Faculty)
.Include(p => p.Promoter.Institute)
.FirstOrDefaultAsync(p => p.Id == id);
if (proposal == null)
{
return(ServiceResult <FileDescription> .Error($"Proposal with id {id} does not exist."));
}
var proposalDocRecord = _mapper.Map <ProposalDocRecord>(proposal);
var result = _diplomaCardCreator.CreateDiplomaCard(proposalDocRecord);
var fileName = $"karta_tematu_pracy_{proposal.Id}.docx";
var fileDescription = new FileDescription {
Name = fileName,
Bytes = result.Body().ToArray()
};
return(ServiceResult <FileDescription> .Success(fileDescription));
}
public async Task <ServiceResult <int> > DeleteAsync(ClaimsPrincipal user, int groupId, int transactionId)
{
var group = groupsRepository.Get(groupId);
if (group is null)
{
return(ServiceResult <int> .Error(404, "Group was not found"));
}
var authorizationResult = await authorizationService.AuthorizeAsync(user, group, GroupOperations.Write);
if (!authorizationResult.Succeeded)
{
return(ServiceResult <int> .Error(401, "Unauthorized"));
}
var transaction = transactionsRepository.Get(transactionId);
if (transaction is null || transaction.GroupId != groupId)
{
return(ServiceResult <int> .Error(404, "Transaction was not found"));
}
transaction.Deleted = true;
var result = await transactionsRepository.UpdateAsync(transaction);
if (result is null)
{
return(ServiceResult <int> .Error(500, "Error deleting transaction"));
}
return(ServiceResult <int> .Success(TransactionViewModel.FromModel(result)));
}
public async Task <IServiceResult <IEnumerable <ProposalViewModel> > > GetMyProposals()
{
var userResult = await _userGetter.GetCurrentUser();
if (!userResult.Successful())
{
var errors = userResult.GetAggregatedErrors();
return(ServiceResult <IEnumerable <ProposalViewModel> > .Error(errors));
}
var currentUser = userResult.Body();
var promoter =
await _context
.Promoters
.Include(p => p.Proposals)
.FirstOrDefaultAsync(p => p.UserId == currentUser.Id);
if (promoter == null)
{
return(ServiceResult <IEnumerable <ProposalViewModel> > .Error("The current user has no associated promoter"));
}
var proposalViewModels = promoter
.Proposals
.Select(p => _mapper.Map <ProposalViewModel>(p));
return(ServiceResult <IEnumerable <ProposalViewModel> > .Success(proposalViewModels));
}
public async Task <ServiceResult <int> > UpdateAsync(ClaimsPrincipal user, int groupId, int transactionId, TransactionRequestModel transaction)
{
var group = groupsRepository.Get(groupId);
if (group is null)
{
return(ServiceResult <int> .Error(404, "Group was not found"));
}
var authorizationResult = await authorizationService.AuthorizeAsync(user, group, GroupOperations.Write);
if (!authorizationResult.Succeeded)
{
return(ServiceResult <int> .Error(401, "Unauthorized"));
}
var transactionEntity = transactionsRepository.Get(transactionId);
if (transactionEntity is null || transactionEntity.GroupId != groupId)
{
return(ServiceResult <int> .Error(404, "Transaction was not found"));
}
transactionEntity.Amount = transaction.Amount;
transactionEntity.Description = transaction.Description;
transactionEntity.CategoryId = transaction.CategoryId;
var result = await transactionsRepository.UpdateAsync(transactionEntity);
if (result is null)
{
return(ServiceResult <int> .Error(500, "Could not update transaction"));
}
return(ServiceResult <int> .Success(TransactionViewModel.FromModel(result)));
}
public async Task Update_UpdatingFailed_AddLogAndReturnServiceErrorResult()
{
// Arrange
var request = new UpdateSampleRequest {
Id = 1
};
var model = new Sample {
Id = 1, CreatedDate = It.IsAny <DateTime>()
};
var exception = It.IsAny <Exception>();
var serviceResult = ServiceResult.Error(Messages.UpdatingFailed);
repository.Setup(x => x.GetAsync(s => s.Id == request.Id)).ReturnsAsync(model);
sampleFactory.Setup(x => x.CreateUpdateSample(model, request)).Returns(model);
repository.Setup(x => x.Update(model)).Throws(exception);
// Act
var result = await service.Update(request);
// Assert
result.IsSuccess.Should().BeFalse();
result.Message.Should().Be(serviceResult.Message);
unitOfWork.Verify(x => x.Save(), Times.Never);
AssertHelpers.VerifyLogger(logger, LogLevel.Error, Times.Once());
}
public async Task <IServiceResult <PromoterViewModel> > Update(
int id,
PromoterUpdate newData)
{
var existingPromoter =
await _context
.Promoters
.Include(p => p.ApplicationUser)
.FirstOrDefaultAsync(p => p.Id == id);
if (existingPromoter == null)
{
return(ServiceResult <PromoterViewModel> .Error(
$"Promoter with id {id} does not exist"));
}
existingPromoter = _mapper.Map(newData, existingPromoter);
_context.Promoters.Update(existingPromoter);
await _context.SaveChangesAsync();
var promoterViewModel = _mapper.Map <PromoterViewModel>(existingPromoter);
return(ServiceResult <PromoterViewModel> .Success(promoterViewModel));
}
public async Task <ServiceResult <JwtTokenApiModel> > LoginAsync(LoginDto model)
{
var result = ServiceResult <JwtTokenApiModel> .OK();
try
{
var user = await _uow.Repository <User>().Get()
.FirstOrDefaultAsync(u => u.Email == model.Email.ToLower());
if (user == null || !user.PasswordHash.VerifyHashed(model.Password))
{
return(ServiceResult <JwtTokenApiModel> .Error(StringConstants.AuthFailed));
}
if (!user.Verified)
{
return(ServiceResult <JwtTokenApiModel> .Error(StringConstants.NotActivated));
}
result.Entity = new JwtTokenApiModel()
{
AccessToken = user.GenerateIdentity().GenerateIdentityToken(_authSettings)
};
}
catch (Exception e)
{
_logger.LogException(e);
result = ServiceResult <JwtTokenApiModel> .Error(StringConstants.DatabaseError);
}
return(result);
}
//[ValidateDNTCaptcha(CaptchaGeneratorLanguage = DNTCaptcha.Core.Providers.Language.Persian)]
public async Task <IActionResult> Index(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new User();
Mapper.Map(model, user);
if (model.UserType == UserTypeSSOT.Person)
{
user.UserName = model.NationalCode;
}
else
{
user.UserName = model.Email;
}
user.EmailConfirmed = true;
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
_logger.LogInformation($"کاربر {user.UserName} از طریق سایت ثبت نام کرده است.");
var ChangePhoneNumberToken = await _userManager.GenerateChangePhoneNumberTokenAsync(user, model.PhoneNumber);
_smsService.sendMessage(model.PhoneNumber, "به سامانه کارآموزی خوش آمدید.");
//var smsResult = await _smsSender.SendSmsAsync(model.PhoneNumber, $"برای تکمیل ثبت نام خود کد : {ChangePhoneNumberToken} را وارد نمایید.");
if (model.UserType == UserTypeSSOT.Person)
{
await _userManager.AddToRoleAsync(user, ConstantRoles.UserBase);
}
if (model.CreateByAdmin.HasValue && model.CreateByAdmin == true)
{
return(Redirect("~/Identity/UsersManager/Index"));
}
else
{
await _signInManager.SignInAsync(user, false, null);
return(Redirect("/"));
}
}
List <string> errors = new List <string>();
foreach (var error in result.Errors)
{
//ModelState.AddModelError(string.Empty, error.Description);
errors.Add(error.Description);
}
TempData.AddResult(ServiceResult.Error(string.Join("<br/>", errors)));
}
ViewBag.UserType = model.UserType;
return(View(model));
}
public async Task <ServiceResult <IssueModel> > Create(NewIssueModel model, string userId)
{
var isMember = await IsMember(model.ProjectId, userId);
if (!isMember)
{
return(ServiceResult <IssueModel> .Error(ProjectsConstants.NotAMember));
}
var issue = new Issue(userId);
issue.InjectFrom(model);
await _dbContext.Issues.AddAsync(issue);
var count = await SaveChangesAsync();
if (count != 1)
{
return(ServiceResult <IssueModel> .Error("Something went wrong"));
}
var resultModel = GetModelFromEntity(issue);
return(ServiceResult <IssueModel> .Ok(resultModel));
}
public async Task <ServiceResult <int> > Get(ClaimsPrincipal user, int groupId, int actionId)
{
var group = groupsRepository.Get(groupId);
if (group is null)
{
return(ServiceResult <int> .Error(404, "Group was not found"));
}
var authorizationResult = await authorizationService.AuthorizeAsync(user, group, GroupOperations.Write);
if (!authorizationResult.Succeeded)
{
return(ServiceResult <int> .Error(401, "Unauthorized"));
}
var action = actionsRepository.Get(actionId);
if (action is null || action.GroupId != groupId)
{
return(ServiceResult <int> .Error(404, "Action was not found"));
}
return(ServiceResult <int> .Success(ActionViewModel.FromModel(action)));
}
public async Task <ServiceResult <ProjectModel> > CreateNewProject(NewProjectModel model, string userId)
{
var count = await GetAllProjectsQuery(userId).CountAsync();
if (count > 9)
{
return(ServiceResult <ProjectModel> .Error("You cant create more then 10 projects"));
}
var newProject = new Project(userId);
newProject.InjectFrom(model);
var projectMember = new Member(userId)
{
Role = ProjectRoleEnum.Owner,
};
newProject.Members.Add(projectMember);
await _dbContext.Projects.AddAsync(newProject);
await _dbContext.SaveChangesAsync();
var resultModel = new ProjectModel();
resultModel.InjectFrom(newProject);
return(ServiceResult <ProjectModel> .Ok(resultModel));
}
public IActionResult Index(ForgotPasswordViewModel model)
{
if (ModelState.IsValid)
{
var user = _userService.GetUserByNationalCode(model.NationalCode);
if (user == null)
{
TempData.AddResult(ServiceResult.Error("کدملی وارد شده در سامانه وجود ندارد."));
return(View("Error"));
}
if (user.PhoneNumber.Trim() != model.PhoneNumber.Trim())
{
TempData.AddResult(ServiceResult.Error("تلفن همراه وارد شده با تلفن همراه این کدملی در سامانه مقایرت دارد."));
return(RedirectToAction(nameof(Index)));
}
var randomCode = _userService.GenerateRandomNumber(10000, 99999);
user.RandomCode = randomCode;
_userService.UpdateUser(user);
_smsService.sendMessage(model.PhoneNumber, $"<<سامانه کارآموزی>>\n \n" +
$"کد فعال سازی: {randomCode}");
return(RedirectToAction(nameof(ForgetPasswordSmsConfirmation), model));
}
else
{
return(View(model));
}
}
public async Task <ServiceResult <MemberModel> > AddMember(NewMemberModel model, string userId)
{
var project = await _dbContext.Projects
.FirstOrDefaultAsync(p => p.Id == model.ProjectId &&
p.DeletedByUserId == null &&
p.Members.Any(m => m.MemberId == userId && HeadOfProjectRoles.Contains(m.Role)));
if (project == null)
{
return(ServiceResult <MemberModel> .NotFound("Project not found or you are cant moderate it"));
}
var alreadyExistMember = project.Members.Any(m => m.MemberId == model.MemberId);
if (alreadyExistMember)
{
return(ServiceResult <MemberModel> .Error("User already in project"));
}
var newMember = (Member) new Member(userId).InjectFrom(model);
project.Members.Add(newMember);
var count = await _dbContext.SaveChangesAsync();
if (count != 1)
{
return(ServiceResult <MemberModel> .Error("Something went wrong"));
}
var memberModel = (MemberModel) new MemberModel().InjectFrom(newMember);
return(ServiceResult <MemberModel> .Ok(memberModel));
}
public async Task <ServiceResult <string> > DeleteAsync(ClaimsPrincipal userClaims, string id)
{
var authorizationResult = await authorizationService.AuthorizeAsync(userClaims, id, new UserIsSelfRequirement());
if (!authorizationResult.Succeeded)
{
return(ServiceResult <string> .Error(401, "Trying to delete other user"));
}
var user = await usersManager.FindByIdAsync(id);
if (user is null)
{
return(ServiceResult <string> .Error(404, "User not found"));
}
if (id != user.Id)
{
return(ServiceResult <string> .Error(403, "Cannot modify other users"));
}
user.Deleted = true;
var result = await usersManager.UpdateAsync(user);
if (!result.Succeeded)
{
return(ServiceResult <string> .Error(500, "Error deleting user"));
}
return(ServiceResult <string> .Success(UserViewModel.FromModel(user)));
}
