public IResult ActivateEmail(User user, string token) { IDataResult <UserToken> userTokenResult = _userTokenSevice.GetEmailConfirmTokenByUserId(user.Id); if (!userTokenResult.Success || userTokenResult.Data == null) { return(new ErrorResult(SecurityMessages.SystemError)); } if (userTokenResult.Data.Value != token) { return(new ErrorResult(SecurityMessages.InvalidTransaction)); } if (userTokenResult.Data.Expiration < DateTime.Now) { _userTokenSevice.Delete(userTokenResult.Data); return(new ErrorResult(SecurityMessages.TokenHasExpiredForEmailConfirm)); } user.EmailConfirmed = true; using (TransactionScope transaction = new TransactionScope()) { _userDal.Update(user); _userTokenSevice.Delete(userTokenResult.Data); transaction.Complete(); } return(new SuccessResult(SecurityMessages.UserEmailActivated)); }
public IActionResult Update(WidgetDTO widgetDTO, int Id) { if (!ModelState.IsValid) { return(BadRequest(ModelState.GetErrorMessage())); } else { IDataResult <Widget> result = _iWidgetService.GetById(Id); if (result == null) { return(BadRequest(result.Message)); } else { _iMapper = WidgetMapping.GetMapper().CreateMapper(); Widget widget = _iMapper.Map <WidgetDTO, Widget>(widgetDTO); IResult updateResult = _iWidgetService.Update(widget); if (updateResult.Success) { return(Ok(updateResult.Message)); } return(BadRequest(updateResult.Message)); } } }
private void LoadData(int taskId) { CmbEmployeeList.Items.Clear(); var emp = _employeeService.GetList().Data; _task = _taskService.GetById(taskId); if (_task.IsSuccessful) { rctDetails.Text = _task.Data.Details; rctNotes.Text = _task.Data.Notes; estDateTime.Value = _task.Data.EstimatedDate; SetState((TaskStateBaseNames)_task.Data.TaskStateId); CmbEmployeeList.Items.Clear(); foreach (var employee in emp) { if (_task.Data.Employees.FirstOrDefault(employee1 => employee1.Id == employee.Id) == null) { CmbEmployeeList.Items.Add(employee); } } lstMembers.Items.Clear(); lstMembers.Items.AddRange(_task.Data.Employees.ToArray()); } }
public async Task <IActionResult> MyOrders() { int userId = Convert.ToInt32(User.FindFirst("UserId") !.Value); IDataResult <List <Order> > orderResult = await _orderService.GetListByUserId(userId); return(View(orderResult)); }
public IActionResult ResetPasswordForForgetten([FromBody] ForgettingPasswordDto forgettingPasswordDto) { IDataResult <User> userResult = _userService.GetById(forgettingPasswordDto.UserId); if (!userResult.Success || userResult.Data == null) { return(BadRequest(new ErrorResultDto { Name = ErrorNames.DefaultError, Type = ErrorTypes.Danger, Value = SecurityMessages.SystemError })); } IResult result = _userService.ResetPasswordForForgetten(userResult.Data, forgettingPasswordDto.Token, forgettingPasswordDto.Password); if (!result.Success) { return(BadRequest(new ErrorResultDto { Name = ErrorNames.ResetPasswordError, Type = ErrorTypes.Danger, Value = result.Message })); } return(Ok(result.Message)); }
/*--------------------------------------------------------------------------------------------*/ public void PerformChecks(IDataResult pResult) { foreach (IDataResultCheck check in vChecks) { check.PerformCheck(pResult); } }
public async Task <IActionResult> Basket(CreateOrderDto createOrderDto) { if (!ModelState.IsValid) { int userId = Convert.ToInt32(User.FindFirst("UserId").Value); createOrderDto.UserAddresses = await _userAddressService.GetListAsync(userId); return(View(createOrderDto)); } IDataResult <CartDTO> cart = await _cartService.GetCart(); if (cart.IsSuccess) { Order result = await _orderService.CreateOrder(cart.Data, createOrderDto); if (result.Id != 0) { TempData["ToastModel"] = result.Id.ToString(); } else { TempData["ToastModel"] = "Bir Hata ile karşılaşıldı !"; } } else { TempData["ToastModel"] = "Sepette Ürün Bulunamadı !"; } return(RedirectToAction(nameof(PaymentResult), "Cart")); }
public IActionResult Update(UserGroupDTO userGroupDTO, int Id) { if (!ModelState.IsValid) { return(BadRequest(ModelState.GetErrorMessage())); } else { IDataResult <UserGroup> result = _iUserGroupService.GetById(Id); if (result == null) { return(BadRequest(result.Message)); } else { _iMapper = UserGroupMapping.GetMapper().CreateMapper(); UserGroup userGroup = _iMapper.Map <UserGroupDTO, UserGroup>(userGroupDTO); IResult updateResult = _iUserGroupService.Update(userGroup); if (updateResult.Success) { return(Ok(updateResult.Message)); } return(BadRequest(updateResult.Message)); } } }
public IActionResult Post(RentCarToCustomerRequest request, [FromServices] ICustomerService _customerService, [FromServices] ICarService _carService) { IDataResult <Customer> getCustomerResult = _customerService.GetById(request.customerId); if (!getCustomerResult.Success) { return(BadRequest(getCustomerResult)); } Customer customer = getCustomerResult.Data; IDataResult <Car> getCarResult = _carService.GetById(request.carId); if (!getCarResult.Success) { return(BadRequest(getCarResult)); } Car car = getCarResult.Data; IDataResult <Rental> rentResult = _rentalService.RentACarToCustomer(customer, car); if (rentResult.Success) { return(Ok(rentResult)); } return(BadRequest(rentResult)); }
public IDataResult <User> Register(UserForRegisterDto userForRegisterDto) { Validation <UserForRegisterValidator> validation = new Validation <UserForRegisterValidator>(); validation.Validate(userForRegisterDto); var user = _mapper.Map <User>(userForRegisterDto); if (!UserExists(userForRegisterDto.Email).IsSuccessful) { UserForPasswordDto userForPasswordDto = new UserForPasswordDto { Password = userForRegisterDto.Password }; HashingHelper.CreatePasswordHash(userForPasswordDto); user.PasswordHash = userForPasswordDto.PasswordHash; user.PasswordSalt = userForPasswordDto.PasswordSalt; user.IsActive = false; IDataResult <User> result = _userService.Add(user); if (!result.IsSuccessful) { return(new ErrorDataResult <User>(result.Message, user)); } return(new SuccessDataResult <User>(result.Message, result.Data)); } return(new ErrorDataResult <User>(Messages.UserAlreadyExists, null)); }
public async Task <IActionResult> UpdateAsync(UserGroupDTO userGroupDTO, int Id) { if (!ModelState.IsValid) { return(BadRequest(ModelState.GetErrorMessage())); } else { IDataResult <UserGroup> dataResult = await _iUserGroupService.FindByIdAsync(Id); if (dataResult.Data == null) { return(BadRequest(dataResult.Message)); } _iMapper = UserGroupMapping.GetMapper().CreateMapper(); UserGroup userGroup = _iMapper.Map <UserGroupDTO, UserGroup>(userGroupDTO); IResult result = await _iUserGroupService.UpdateAsync(userGroup); if (result.Success) { return(Ok(result.Message)); } return(BadRequest(result.Message)); } }
public IActionResult Delete(int Id) { if (!ModelState.IsValid) { return(BadRequest(ModelState.GetErrorMessage())); } else { IDataResult <ChartType> dataResult = _service.GetById(Id); if (dataResult == null) { return(BadRequest(dataResult.Message)); } else { IResult result = _service.Delete(dataResult.Data); if (result.Success) { return(Ok(result.Message)); } return(BadRequest(result.Message)); } } }
public IActionResult Update(ChartTypeDTO chartTypeDto, int Id) { if (!ModelState.IsValid) { return(BadRequest(ModelState.GetErrorMessage())); } else { IDataResult <ChartType> dataResult = _service.GetById(Id); if (dataResult == null) { return(BadRequest(dataResult.Message)); } else { mapper = ChartTypeMapping.GetMapper().CreateMapper(); ChartType chartType = mapper.Map <ChartTypeDTO, ChartType>(chartTypeDto); IResult result = _service.Update(chartType); if (result.Success) { return(Ok(result.Message)); } return(BadRequest(result.Message)); } } }
public async Task <IDataResult <AccessToken> > CreateAccessTokenWithRefreshToken(string refreshToken) { IDataResult <User> user = await _userService.GetUserWithRefreshToken(refreshToken); if (user.Success) { //Gecerliligi var if (user.Data.RefreshTokenEndDate > DateTime.Now) { AccessToken accessToken = _tokenHandler.CreateAccessToken(user.Data); user.Data.RefreshToken = accessToken.RefreshToken; await _unitOfWork.CompleteAsync(); //await _userService.SaveRefreshToken(user.Data.ID, accessToken.RefreshToken); return(new SuccessDataResult <AccessToken>(accessToken, BasicCrudOperationMessages.CREATE_TOKEN)); } else { return(new FailDataResult <AccessToken>(BasicCrudOperationMessages.ACCESS_TOKEN_ENOUGH_TİME_NOT)); } } else { return(new FailDataResult <AccessToken>( BasicCrudOperationMessages.HAVE_NOT_USER)); } }
public IActionResult Update(SerieDTO serieDTO, int Id) { if (!ModelState.IsValid) { return(BadRequest(ModelState.GetErrorMessage())); } else { IDataResult <Serie> dataResult = _service.GetById(Id); if (dataResult == null) { return(BadRequest(dataResult.Message)); } else { mapper = SerieMapping.GetMapper().CreateMapper(); Serie serie = mapper.Map <SerieDTO, Serie>(serieDTO); IResult result = _service.Update(serie); if (result.Success) { return(Ok(result.Message)); } return(BadRequest(result.Message)); } } }
public IActionResult Post([FromForm] int photoId) { var result = User.Claims.GetUserId(); if (!result.IsSuccessful && photoId > 0) { return(BadRequest()); } IDataResult <Like> dataResult = _likeService.Add(new Like() { UserId = result.Data, PhotoId = photoId }); var channelId = _photoService.GetById(photoId).Data.ChannelId; if (dataResult.IsSuccessful) { this.RemoveCacheByContains(result.Data + "/api/likes/islike/" + photoId); this.RemoveCacheByContains("photos/" + photoId); this.RemoveCacheByContains(channelId + "/channel-photos"); this.RemoveCacheByContains(result.Data + "/user-photos"); this.RemoveCacheByContains(result.Data + "/like-photos"); this.RemoveCacheByContains(result.Data + "/user-comment-photos"); return(Ok(dataResult.Data)); } return(BadRequest(dataResult.Message)); }
protected virtual object Do(string command, object args) { IDataParameters Parameters = new DataParameters(); CommandChannelDoParams commandChannelDoParams = new CommandChannelDoParams(command, args); Parameters.MemberName = nameof(Do); Parameters.ParametersValue = this.objectSerializationHelper.ToByteArray <CommandChannelDoParams>(commandChannelDoParams); IDataResult DataResult = FunctionClient.ExecuteFunction(Parameters); switch (commandChannelDoParams.Command) { case CommandChannelHelper.Command_ExecuteScalarSQL: case CommandChannelHelper.Command_ExecuteScalarSQLWithParams: return(this.objectSerializationHelper.GetObjectsFromByteArray <object>(DataResult.ResultValue)); case CommandChannelHelper.Command_ExecuteQuerySQL: case CommandChannelHelper.Command_ExecuteQuerySQLWithParams: case CommandChannelHelper.Command_ExecuteQuerySQLWithMetadata: case CommandChannelHelper.Command_ExecuteQuerySQLWithMetadataWithParams: case CommandChannelHelper.Command_ExecuteStoredProcedure: case CommandChannelHelper.Command_ExecuteStoredProcedureParametrized: return(this.objectSerializationHelper.GetObjectsFromByteArray <SelectedData>(DataResult.ResultValue)); case CommandChannelHelper.Command_ExecuteNonQuerySQL: case CommandChannelHelper.Command_ExecuteNonQuerySQLWithParams: return(this.objectSerializationHelper.GetObjectsFromByteArray <int>(DataResult.ResultValue)); default: throw new Exception($"ICommandChannel Do method retuned an unknow data type while processing {commandChannelDoParams.Command}"); } }
public void Execute() { IDataResult result = vData.Execute(vBasicQuery, "TEST"); Assert.AreEqual(vMockAcc.MockResult.Object, result, "Incorrect result."); Assert.AreEqual(1, vData.DbQueryExecutionCount, "Incorrect DbQueryExecutionCount."); }
/*--------------------------------------------------------------------------------------------*/ private OauthMember GetOauthMember(IOperationData pData, Member pMemPath, string pName) { IWeaverVarAlias <Member> memAlias; IWeaverQuery memQ = pMemPath.ToQueryAsVar("m", out memAlias); IWeaverQuery appQ = Weave.Inst.FromVar(memAlias) .DefinedByApp.ToApp .Property(x => x.VertexId) .ToQuery(); IDataAccess acc = pData.Build(null, true); acc.AddSessionStart(); acc.AddQuery(memQ, true); acc.AppendScriptToLatestCommand("(m?m=m.next():null);"); string memCmdId = acc.GetLatestCommandId(); acc.AddQuery(appQ, true); acc.AddConditionsToLatestCommand(memCmdId); acc.AddSessionClose(); IDataResult res = acc.Execute("OauthAccess-" + pName); if (res.GetCommandResultCount(1) == 0) { return(null); } var om = new OauthMember(); om.Member = res.ToElementAt <Member>(1, 0); om.AppId = res.ToLongAt(2, 0); return(om); }
public MockFixtureService MockGetById(IDataResult <Fixture> result) { Setup(x => x.GetById(It.IsAny <Guid>())) .Returns(result); return(this); }
public async Task <JsonResult> AddToCart(AddToCartDTO model) { IDataResult <CartDTO> cart = await _cartService.AddToCart(model); //todo cart IsSuccess Kontrolü Yap return(Json(new { totalPrice = cart.Data.CartTotal, CartCount = cart.Data.CartItemsCount })); }
public async Task <IActionResult> UpdateAsync(DataSourceTypeDTO dataSourceTypeDTO, int Id) { if (!ModelState.IsValid) { return(BadRequest(ModelState.GetErrorMessage())); } else { IDataResult <DataSourceType> dataResult = await _iDataSourceTypeService.FindByIdAsync(Id); if (dataResult.Data == null) { return(BadRequest(dataResult.Message)); } _iMapper = DataSourceTypeMapping.GetMapper().CreateMapper(); DataSourceType dataSourceType = _iMapper.Map <DataSourceTypeDTO, DataSourceType>(dataSourceTypeDTO); IResult result = await _iDataSourceTypeService.UpdateAsync(dataSourceType); if (result.Success) { return(Ok(result.Message)); } return(BadRequest(result.Message)); } }
public IActionResult ActivateEmail([FromBody] ActivateEmailDto activateEmailDto) { IDataResult <User> userResult = _userService.GetById(activateEmailDto.UserId); if (!userResult.Success || userResult.Data == null) { return(BadRequest(new ErrorResultDto { Name = ErrorNames.DefaultError, Type = ErrorTypes.Danger, Value = SecurityMessages.SystemError })); } IResult result = _userService.ActivateEmail(userResult.Data, activateEmailDto.Token); if (!result.Success) { return(BadRequest(new ErrorResultDto { Name = ErrorNames.ActivatedErrorEmail, Type = ErrorTypes.Danger, Value = result.Message })); } return(Ok(result.Message)); }
public IActionResult Update(DataSourceTypeDTO dataSourceTypeDTO, int Id) { if (!ModelState.IsValid) { return(BadRequest(ModelState.GetErrorMessage())); } else { IDataResult <DataSourceType> result = _iDataSourceTypeService.GetById(Id); if (result == null) { return(BadRequest(result.Message)); } else { _iMapper = DataSourceTypeMapping.GetMapper().CreateMapper(); DataSourceType dataSource = _iMapper.Map <DataSourceTypeDTO, DataSourceType>(dataSourceTypeDTO); IResult updateResult = _iDataSourceTypeService.Update(dataSource); if (updateResult.Success) { return(Ok(updateResult.Message)); } return(BadRequest(updateResult.Message)); } } }
public async Task <IActionResult> UpdateAsync(WidgetDTO widgetDTO, int Id) { if (!ModelState.IsValid) { return(BadRequest(ModelState.GetErrorMessage())); } else { IDataResult <Widget> dataResult = await _iWidgetService.FindByIdAsync(Id); if (dataResult.Data == null) { return(BadRequest(dataResult.Message)); } _iMapper = WidgetMapping.GetMapper().CreateMapper(); Widget widget = _iMapper.Map <WidgetDTO, Widget>(widgetDTO); IResult result = await _iWidgetService.UpdateAsync(widget); if (result.Success) { return(Ok(result.Message)); } return(BadRequest(result.Message)); } }
public async Task <IDataResult <List <CarDetailDto> > > GetAllWithDetail(ICarImageService carImageService) { List <CarDetailDto> cars = _carDal.GetCarsWithDetail(); if (cars.Count == 0) { return(new ErrorDataResult <List <CarDetailDto> >()); } foreach (CarDetailDto car in cars) { car.Images = new List <CarImageDto>(); IDataResult <List <CarImage> > carImagesResult = await carImageService.GetImagesByCarId(car.Id); if (!carImagesResult.Success) { car.Images.Add(new CarImageDto { ImagePath = "default-path" }); // TODO } else { foreach (CarImage carImage in carImagesResult.Data) { car.Images.Add(new CarImageDto { ImagePath = carImage.ImagePath }); } } } return(new SuccessDataResult <List <CarDetailDto> >(cars)); }
public IActionResult Delete(int Id) { if (!ModelState.IsValid) { return(BadRequest(ModelState.GetErrorMessage())); } else { IDataResult <Widget> result = _iWidgetService.GetById(Id); if (result == null) { return(BadRequest(result.Message)); } else { IResult deleteResult = _iWidgetService.Delete(result.Data); if (deleteResult.Success) { return(Ok(deleteResult.Message)); } else { return(BadRequest(deleteResult.Message)); } } } }
public void Success() { FabOauthLogout result = ExecuteOperation(); Assert.AreEqual(1, result.Success, "Incorrect Success."); Assert.AreEqual(vToken, result.AccessToken, "Incorrect AccessToken."); VerificationQueryFunc = () => { IWeaverQuery q1 = Weave.Inst.Graph .V.ExactIndex <Member>(x => x.VertexId, (long)SetupMemberId.FabZach) .AuthenticatedByOauthAccesses.ToOauthAccess .Has(x => x.Token) .ToQuery(); IWeaverQuery q2 = Weave.Inst.Graph .V.ExactIndex <Member>(x => x.VertexId, (long)SetupMemberId.FabZach) .AuthenticatedByOauthAccesses.ToOauthAccess .Has(x => x.Refresh) .ToQuery(); IDataResult dr1 = OpCtx.ExecuteForTest(q1, "OauthLogoutOperation-Token"); IDataResult dr2 = OpCtx.ExecuteForTest(q2, "OauthLogoutOperation-Refresh"); Assert.AreEqual(0, dr1.GetCommandResultCount(), "Tokens were not cleared."); Assert.AreEqual(0, dr2.GetCommandResultCount(), "Refresh were not cleared."); }; }
public async Task <IActionResult> UpdateAsync(FirmDTO firmDTO, int Id) { if (!ModelState.IsValid) { return(BadRequest(ModelState.GetErrorMessage())); } else { IDataResult <Firm> firmDataResult = await _Firmservice.FindByIdAsync(Id); if (firmDataResult.Data == null) { return(BadRequest(firmDataResult.Message)); } _mapper = FirmMapping.GetMapper().CreateMapper(); Firm firm = _mapper.Map <FirmDTO, Firm>(firmDTO); firm.ID = firmDataResult.Data.ID; IResult firmResult = await _Firmservice.UpdateAsync(firm); if (firmResult.Success) { return(Ok(firmResult.Message)); } else { return(BadRequest(firmResult.Message)); } } }
public IDataResult <AccessToken> CreateAccessToken(IDataResult <User> dataResult) //jwt oluşturma { var claims = _userService.GetClaims(dataResult.Data).Data; //user üzerinden rolleri çekiliyor var accessToken = _tokenHelper.CreateToken(dataResult.Data, claims); //jwt oluşuyor return(new SuccessDataResult <AccessToken>(accessToken, dataResult.Message)); }