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));
}
