public ActionResult <CommonResponeModel> Create(UserCreateRequestModel model)
{
if (userRepository.IsExistUsername(model.Username))
{
string message = UserMessageGlobal.ExistUsername;
Result = new ErrorResult(ActionType.Login, message);
}
else
{
var databaseObject = model.MapTo <User>();
databaseObject.InitBeforeSave(RequestUsername, InitType.Create);
databaseObject.InitDefault();
databaseObject.SetPassword();
int result = userRepository.Insert(databaseObject);
if (result > 0)
{
Result = new SuccessResult(ActionType.Insert, AppGlobal.CreateSucess);
Data = databaseObject;
}
else
{
Result = new ErrorResult(ActionType.Insert, AppGlobal.CreateError);
Data = databaseObject;
}
}
return(GetCommonRespone());
}
public SuccessResult Submit(string userNo, T_Setting setting)
{
SuccessResult successResult = new SuccessResult();
successResult.Success = false;
try
{
setting.PalletUrl = ConfigurationManager.AppSettings["PalletUrl"]
+ setting.HouseNo + "&OrderType=" + setting.OrderType;
var settings = GetList();
if (settings.Find(x => x.PalletUrl == setting.PalletUrl) != null)
{
successResult.Msg = "该仓库该看板类型地址已存在!";
return(successResult);
}
setting.Id = Guid.NewGuid().ToString();
setting.Creater = userNo;
setting.CreateTime = DateTime.Now;
Insert(setting);//新增
successResult.Msg = "生成成功!";
successResult.Success = true;
}
catch (Exception ex)
{
successResult.Msg = ex.Message;
}
return(successResult);
}
public ActionResult <CommonResponeModel> Delete(UserDeleteRequestModel model)
{
var user = userRepository.GetByUsername(model.Username);
if (user != null)
{
user.IsActive = false; //Set user to in active
user.InitBeforeSave(RequestUsername, InitType.Update);
int result = userRepository.Update(user);
if (result > 0)
{
Result = new SuccessResult(ActionType.Delete, AppGlobal.DeleteSuccess);
Data = user;
}
else
{
Result = new ErrorResult(ActionType.Delete, AppGlobal.DeleteError);
Data = user;
}
}
else
{
string message = UserMessageGlobal.NotExistUser;
Result = new ErrorResult(ActionType.Login, message);
}
return(GetCommonRespone());
}
public async Task <Result <bool> > HandleAsync(RemoveRestaurantCommand command, User currentUser, CancellationToken cancellationToken = default)
{
if (command == null)
{
throw new ArgumentNullException(nameof(command));
}
if (currentUser == null)
{
return(FailureResult <bool> .Unauthorized());
}
if (currentUser.Role < Role.SystemAdmin)
{
return(FailureResult <bool> .Forbidden());
}
var dishCategories = await dishCategoryRepository.FindByRestaurantIdAsync(command.RestaurantId, cancellationToken);
if (dishCategories != null && dishCategories.Count > 0)
{
return(FailureResult <bool> .Create(FailureResultCode.RestaurantContainsDishCategories));
}
var dishes = await dishRepository.FindByRestaurantIdAsync(command.RestaurantId, cancellationToken);
if (dishes != null && dishes.Count > 0)
{
return(FailureResult <bool> .Create(FailureResultCode.RestaurantContainsDishes));
}
await restaurantRepository.RemoveAsync(command.RestaurantId, cancellationToken);
return(SuccessResult <bool> .Create(true));
}
public async Task Should_Get_Async_Result_When_Available()
{
var result = "result";
var failableAsyncResult = SuccessResult <string, bool> .CreateAsync(result);
Assert.AreEqual(result, await failableAsyncResult.GetResultOrThrowExceptionAsync(f => new Exception()));
}
public ActionResult <AnonymousTrackingResponse> Post()
{
var anonymousTrackingId = GetAnonymousUserTrackingId();
var response = new SuccessResult <AnonymousTrackingResponse>(new AnonymousTrackingResponse(anonymousTrackingId));
return(GetResult(response));
}
protected IResult <IReadOnlyCollection <T> > GetAll(string procedureName, Mapper <DataSet, T> mapper, IDictionary <string, object> values = null)
{
IReadOnlyCollection <T> entities = null;
IResult <IReadOnlyCollection <T> > result = new NoneResult <IReadOnlyCollection <T> >();
try
{
using (var dataSet = _context.ExecuteProcedure(procedureName, values))
{
if (this.CheckDataSet(dataSet))
{
entities = mapper?.MapCollection(dataSet);
}
}
}
catch (UserException ex)
{
result = new FailureResult <IReadOnlyCollection <T> >(ex, ex.Message);
}
if (entities != null)
{
result = new SuccessResult <IReadOnlyCollection <T> >(entities);
}
return(result);
}
public ActionResult <CommonResponeModel> Update(CategorySaveChangeRequestModel request)
{
var result = 0;
var model = request.MapTo <Category>();
var currentObj = this.categoryRepository.GetById(model.Id);
if (currentObj != null)
{
model.InitBeforeSave(RequestUsername, InitType.Update);
result = this.categoryRepository.Update(model);
}
else
{
Result = new ErrorResult(ActionType.Select, CommonMessageGlobal._404);
}
if (result > 0)
{
Result = new SuccessResult(ActionType.Insert, AppGlobal.SaveChangeSuccess);
}
else
{
Result = new ErrorResult(ActionType.Insert, AppGlobal.SaveChangeFalse);
}
return(GetCommonRespone());
}
/// <summary>
/// Adds a track to a conference
/// </summary>
/// <param name="trackId">Unique identity of a track</param>
/// <param name="talkId">Unique identity of a talk</param>
/// <param name="title">Title of Talk</param>
/// <param name="description">Description of talk</param>
/// <param name="duration">Duration/Length of talk</param>
/// <returns>An instance of <c>TrackId</c></returns>
public Result <TalkId> AddTalkToTrack(TrackId trackId, TalkId talkId, Title title, Description description, Duration duration)
{
var track = _tracks.FirstOrDefault(t => t.TrackId == trackId);
if (track == null)
{
return(InvalidResult <TalkId> .Create("Invalid track"));
}
var talkAddedToTrackResult = track.CreateAndAddTalk(talkId, title, description, duration);
if (talkAddedToTrackResult.IsFailure)
{
return(InvalidResult <TalkId> .Create(talkAddedToTrackResult.Error.Value.Message));
}
var addedTalk = talkAddedToTrackResult.Data;
var talkCreated = new TalkCreated(addedTalk.TalkId, addedTalk.Title, addedTalk.Description,
addedTalk.StartTime);
AddEvent(talkCreated);
var trackAddedToTack = new TalkAddedToTrack(track.TrackId, addedTalk.TalkId, addedTalk.Title, addedTalk.StartTime);
AddEvent(trackAddedToTack);
return(SuccessResult <TalkId> .Create(talkId));
}
public async Task <IActionResult> LoginAsync(Authentication model)
{
try
{
if (!ModelState.IsValid)
{
ViewBag.Notification = new SuccessResult(false, "Username and Password are required!");
return(View(model));
}
var obj = await _authenticateService.Authenticate(model);
SuccessResult sr = null;
if (obj.Item1)
{
var token = obj.Item2;
Session.SetString("Token", obj.Item2);
TempData["SuccessResultF"] = true;
TempData["SuccessResultM"] = "You are logged succssfully!";
return(RedirectToAction("Index", "Home"));
}
else
{
sr = new SuccessResult(obj.Item1, obj.Item2);
ViewBag.Notification = sr;
return(View(model));
}
}
catch (Exception)
{
return(View(model));
}
}
public async Task <IResult> AddList(IEnumerable <TEntity> entities)
{
IResult result;
try
{
if (typeof(ILogEntity).IsAssignableFrom(typeof(ILogEntity)))
{
foreach (var item in typeof(TEntity).GetFields().Where(x => typeof(ILogEntity).GetFields().Select(x => x.Name).Contains(x.Name)))
{
if (item.Name == "CreatedTime")
{
item.SetValue(null, DateTime.Now);
}
if (item.Name == "UserId")
{
item.SetValue(null, 0);
}
}
}
await _baseDal.Add(entities);
result = new SuccessResult("List Adding was succesed");
}
catch (Exception ex)
{
result = new ErrorResult(ex.Message);
}
return(result);
}
public async Task <Result <bool> > HandleAsync(ChangePaymentMethodCommand command, User currentUser, CancellationToken cancellationToken = default)
{
if (command == null)
{
throw new ArgumentNullException(nameof(command));
}
if (currentUser == null)
{
return(FailureResult <bool> .Unauthorized());
}
if (currentUser.Role < Role.SystemAdmin)
{
return(FailureResult <bool> .Forbidden());
}
var paymentMethod = await paymentMethodRepository.FindByPaymentMethodIdAsync(command.PaymentMethodId, cancellationToken);
if (paymentMethod == null)
{
return(FailureResult <bool> .Create(FailureResultCode.PaymentMethodDoesNotExist));
}
paymentMethod.Change(command.Name, command.Description);
await paymentMethodRepository.StoreAsync(paymentMethod, cancellationToken);
return(SuccessResult <bool> .Create(true));
}
public async Task <Result <UserViewModel> > HandleAsync(AddUserCommand command, User currentUser, CancellationToken cancellationToken = default)
{
if (command == null)
{
throw new ArgumentNullException(nameof(command));
}
if (currentUser == null)
{
return(FailureResult <UserViewModel> .Unauthorized());
}
if (currentUser.Role < Role.SystemAdmin)
{
return(FailureResult <UserViewModel> .Forbidden());
}
var user = await userRepository.FindByNameAsync(command.Name, cancellationToken);
if (user != null)
{
return(FailureResult <UserViewModel> .Create(FailureResultCode.UserAlreadyExists));
}
user = userFactory.Create(command.Name, command.Role, command.Email, command.Password);
await userRepository.StoreAsync(user, cancellationToken);
return(SuccessResult <UserViewModel> .Create(UserViewModel.FromUser(user)));
}
public async Task <Result <CuisineViewModel> > HandleAsync(AddCuisineCommand command, User currentUser, CancellationToken cancellationToken = default)
{
if (command == null)
{
throw new ArgumentNullException(nameof(command));
}
if (currentUser == null)
{
return(FailureResult <CuisineViewModel> .Unauthorized());
}
if (currentUser.Role < Role.SystemAdmin)
{
return(FailureResult <CuisineViewModel> .Forbidden());
}
var cuisine = await cuisineRepository.FindByNameAsync(command.Name, cancellationToken);
if (cuisine != null)
{
return(FailureResult <CuisineViewModel> .Create(FailureResultCode.CuisineAlreadyExists));
}
cuisine = cuisineFactory.Create(command.Name);
await cuisineRepository.StoreAsync(cuisine, cancellationToken);
return(SuccessResult <CuisineViewModel> .Create(CuisineViewModel.FromCuisine(cuisine)));
}
public virtual async Task <NetResult <SuccessResult> > IsRegister(string userName)
{
SuccessResult result = new SuccessResult();
try
{
if (AuthModalOption.SetNameAsPhone && !userName.Contains("@"))
{
userName = RepositoryState.ParsePhone(userName);
}
var user = _user.GetFirst(m => m.UserName == userName || m.Email == userName);
if (user == null)
{
result.Success = false;
}
else
{
result.Success = true;
}
return(result);
}
catch (Exception ext)
{
result.Success = false;
//return ext;
}
return(result);
}
public ActionResult <CommonResponeModel> SaveChange(TrainingCourseEmployeeSaveChangeRequestModel model)
{
var databaseObject = model.MapTo <TrainingCourseEmployee>();
int result = 0;
if (model.Id > 0)
{
result = trainingCourseEmployeeRepository.Update(databaseObject);
}
else
{
result = trainingCourseEmployeeRepository.Insert(databaseObject);
}
if (result > 0)
{
Result = new SuccessResult(ActionType.Edit, AppGlobal.SaveChangeSuccess);
}
else
{
Result = new ErrorResult(ActionType.Edit, AppGlobal.SaveChangeFalse);
}
return(GetCommonRespone());
}
public async Task <Result <bool> > HandleAsync(AddAdminToRestaurantCommand command, User currentUser, CancellationToken cancellationToken = default)
{
if (command == null)
{
throw new ArgumentNullException(nameof(command));
}
if (currentUser == null)
{
return(FailureResult <bool> .Unauthorized());
}
if (currentUser.Role < Role.RestaurantAdmin)
{
return(FailureResult <bool> .Forbidden());
}
var restaurant = await restaurantRepository.FindByRestaurantIdAsync(command.RestaurantId, cancellationToken);
if (restaurant == null)
{
return(FailureResult <bool> .Create(FailureResultCode.RestaurantDoesNotExist));
}
if (currentUser.Role == Role.RestaurantAdmin && !restaurant.HasAdministrator(currentUser.Id))
{
return(FailureResult <bool> .Forbidden());
}
restaurant.AddAdministrator(command.UserId);
await restaurantRepository.StoreAsync(restaurant, cancellationToken);
return(SuccessResult <bool> .Create(true));
}
public Task <IResult <string> > SignInAsync(SignInModel signInModel)
{
var validation = new SignInModelValidator().Valid(signInModel);
if (!validation.Success)
{
return(Task.FromResult(validation));
}
var signedInModel = UserRepository.SignInAsync(signInModel).Result;
validation = new SignedInModelValidator().Valid(signedInModel);
if (!validation.Success)
{
return(Task.FromResult(validation));
}
var userLogModel = new UserLogModel(signedInModel.UserId, LogType.Login);
UserLogDomain.SaveAsync(userLogModel);
var jwt = CreateJwt(signedInModel);
IResult <string> successResult = new SuccessResult <string>(jwt);
return(Task.FromResult(successResult));
}
public void Should_Get_Result_When_Available()
{
var result = "result";
var failableResult = SuccessResult <string, bool> .Create(result);
Assert.AreEqual(result, failableResult.GetResultOrThrowException(f => new Exception()));
}
public async Task <Result <UserViewModel> > HandleAsync(LoginCommand command, User currentUser, CancellationToken cancellationToken = default)
{
if (command == null)
{
throw new ArgumentNullException(nameof(command));
}
if (string.IsNullOrWhiteSpace(command.Username))
{
throw new InvalidOperationException("username is null or whitespace");
}
if (string.IsNullOrWhiteSpace(command.Password))
{
throw new InvalidOperationException("password is null or whitespace");
}
var user = await userRepository.FindByNameAsync(command.Username, cancellationToken);
if (user == null)
{
return(FailureResult <UserViewModel> .Unauthorized());
}
if (!user.ValidatePassword(command.Password))
{
return(FailureResult <UserViewModel> .Unauthorized());
}
return(SuccessResult <UserViewModel> .Create(UserViewModel.FromUser(user)));
}
public ActionResult <CommonResponeModel> Create(CategorySaveChangeRequestModel request)
{
var result = 0;
var model = request.MapTo <Category>();
model.InitBeforeSave(RequestUsername, InitType.Create);
if (string.IsNullOrEmpty(model.Code))
{
var code = this.entityCenterRepository.GetCodeByEntity(nameof(Candidate));
if (string.IsNullOrEmpty(code))
{
Result = new ErrorResult(ActionType.Insert, AppGlobal.MakeCodeError);
return(GetCommonRespone());
}
model.Code = code;
}
result = this.categoryRepository.Insert(model);
if (result > 0)
{
Result = new SuccessResult(ActionType.Insert, AppGlobal.SaveChangeSuccess);
}
else
{
Result = new ErrorResult(ActionType.Insert, AppGlobal.SaveChangeFalse);
}
return(GetCommonRespone());
}
public ActionResult <CommonResponeModel> SaveChangeContact(EmployeeContactDetailRequestModel model)
{
var databaseObject = new Employee();
int result;
if (model.Id == 0)
{
Result = new ErrorResult(ActionType.Insert, CommonMessageGlobal.NotExist("Mã nhân viên"));
return(GetCommonRespone());
}
else
{
databaseObject = employeeRepository.GetById(model.Id);
databaseObject.MapFrom(model);
databaseObject.InitBeforeSave(RequestUsername, InitType.Update);
databaseObject.InitDefault();
result = employeeRepository.Update(databaseObject);
}
if (result > 0)
{
Result = new SuccessResult(ActionType.Edit, AppGlobal.SaveChangeSuccess);
}
else
{
Result = new ErrorResult(ActionType.Edit, AppGlobal.SaveChangeFalse);
}
return(GetCommonRespone());
}
public ActionResult <CommonResponeModel> SaveChange(RoleGroupDetailSaveChangeRequestModel model)
{
var databaseObject = model.MapTo <RoleGroupDetail>();
int result = 0;
if (model.Id > 0)
{
result = roleGroupDetailRepository.Update(databaseObject);
}
else
{
result = roleGroupDetailRepository.Insert(databaseObject);
}
if (result > 0)
{
Result = new SuccessResult(ActionType.Edit, AppGlobal.SaveChangeSuccess);
}
else
{
Result = new ErrorResult(ActionType.Edit, AppGlobal.SaveChangeFalse);
}
return(GetCommonRespone());
}
public async Task <JsonResult> ContactForm(ContactForm form)
{
var result = new SuccessResult();
try
{
var body = new StringBuilder();
body.AppendLine("Ad Soyad: " + form.name + "<br />");
body.AppendLine("Email: " + form.email + "<br /> <br />");
body.AppendLine("Mesaj: " + form.message + "<br />");
await TryNetCore.Utils.SendMail.emailSend("gondericiemail", "aliciemail", form.name, form.subject, body.ToString(), "Şifre");
result.isSuccess = true;
result.Message = "Başarılı";
return(Json(result));
}
catch (Exception e)
{
result.isSuccess = false;
result.Message = e.Message;
return(Json(result));
}
}
public SuccessResult DeleteById(int checkRecordId)
{
SuccessResult successResult = new SuccessResult();
successResult.Success = false;
try
{
var objCheckRecord = new View_CheckRecordService().GetSugarQueryable(x => x.Id == checkRecordId).First();
var result = Db.Ado.UseTran(() =>
{
Delete(checkRecordId);
ProductService productService = new ProductService();
var objRecord = productService.GetSugarQueryable(x => x.ErpVoucherNo == objCheckRecord.ErpVoucherNo).First();
objRecord.QulityQty -= objCheckRecord.RecordQualityQty;
productService.Update(objRecord);
});
if (!result.IsSuccess)
{
throw new Exception(result.ErrorMessage);
}
successResult.Msg = "删除成功!";
successResult.Success = true;
}
catch (Exception ex)
{
successResult.Msg = ex.Message;
}
return(successResult);
}
public async Task <Result <ICollection <RestaurantViewModel> > > HandleAsync(SysAdminSearchForRestaurantsQuery query, User currentUser, CancellationToken cancellationToken = default)
{
if (query == null)
{
throw new ArgumentNullException(nameof(query));
}
if (currentUser == null)
{
return(FailureResult <ICollection <RestaurantViewModel> > .Unauthorized());
}
if (currentUser.Role < Role.SystemAdmin)
{
return(FailureResult <ICollection <RestaurantViewModel> > .Forbidden());
}
var paymentMethods = (await paymentMethodRepository.FindAllAsync(cancellationToken))
.ToDictionary(en => en.Id.Value, PaymentMethodViewModel.FromPaymentMethod);
var restaurants = await restaurantRepository.SearchAsync(query.SearchPhrase, cancellationToken);
return(SuccessResult <ICollection <RestaurantViewModel> > .Create(restaurants
.Select(en => RestaurantViewModel.FromRestaurant(en, paymentMethods, userRepository)).ToList()));
}
protected IResult <T> Get(string procedureName, Mapper <DataSet, T> mapper, IDictionary <string, object> values = null)
{
T obj = default(T);
IResult <T> result = new NoneResult <T>();
try
{
using (var dataSet = _context.ExecuteProcedure(procedureName, values))
{
if (this.CheckDataSet(dataSet) && mapper != null)
{
obj = mapper.MapItem(dataSet);
}
}
}
catch (UserException ex)
{
result = new FailureResult <T>(ex, ex.Message);
}
if (obj != null)
{
result = new SuccessResult <T>(obj);
}
return(result);
}
public async Task <Result <PaymentMethodViewModel> > HandleAsync(AddPaymentMethodCommand command, User currentUser, CancellationToken cancellationToken = default)
{
if (command == null)
{
throw new ArgumentNullException(nameof(command));
}
if (currentUser == null)
{
return(FailureResult <PaymentMethodViewModel> .Unauthorized());
}
if (currentUser.Role < Role.SystemAdmin)
{
return(FailureResult <PaymentMethodViewModel> .Forbidden());
}
var paymentMethod = await paymentMethodRepository.FindByNameAsync(command.Name, cancellationToken);
if (paymentMethod != null)
{
return(FailureResult <PaymentMethodViewModel> .Create(FailureResultCode.PaymentMethodAlreadyExists));
}
paymentMethod = paymentMethodFactory.Create(command.Name, command.Description);
await paymentMethodRepository.StoreAsync(paymentMethod, cancellationToken);
return(SuccessResult <PaymentMethodViewModel> .Create(PaymentMethodViewModel.FromPaymentMethod(paymentMethod)));
}
public async Task Should_Execute_Task_Continuation()
{
var successResult = SuccessResult <int, int> .Create(1);
var failureResult = FailureResult <int, int> .Create(2);
Assert.AreEqual(
2,
await successResult
.OnSuccessAsync(s => Task.FromResult(s * 2))
.OnFailureAsync(f => Task.FromResult(f * 5))
.GetResultOrThrowExceptionAsync(f => new Exception()));
Assert.AreEqual(
2,
await successResult
.OnSuccessAsync(s => SuccessResult <int, int> .CreateAsync(s * 2))
.OnFailureAsync(f => FailureResult <int, int> .CreateAsync(f * 5))
.GetResultOrThrowExceptionAsync(f => new Exception()));
Assert.AreEqual(
4,
await failureResult
.OnFailureAsync(f => Task.FromResult(f * 2))
.OnSuccessAsync(s => Task.FromResult(s * 5))
.HandleAsync(s => 0, f => f));
Assert.AreEqual(
4,
await failureResult
.OnFailureAsync(f => FailureResult <int, int> .CreateAsync(f * 2))
.OnSuccessAsync(s => SuccessResult <int, int> .CreateAsync(s * 5))
.HandleAsync(s => 0, f => f));
}
public async Task <Result <bool> > HandleAsync(ChangeUserPasswordCommand command, User currentUser, CancellationToken cancellationToken = default)
{
if (command == null)
{
throw new ArgumentNullException(nameof(command));
}
if (currentUser == null)
{
return(FailureResult <bool> .Unauthorized());
}
if (currentUser.Role < Role.SystemAdmin)
{
return(FailureResult <bool> .Forbidden());
}
var user = await userRepository.FindByUserIdAsync(command.UserId, cancellationToken);
if (user == null)
{
return(FailureResult <bool> .Create(FailureResultCode.UserDoesNotExist));
}
user.ChangePassword(command.Password);
await userRepository.StoreAsync(user, cancellationToken);
return(SuccessResult <bool> .Create(true));
}
public async void Success(SuccessResult result)
{
var message = string.Format("You have now payed with MobilePay.\nYour MobilePay transactionId is '{0}'", result.TransactionId);
var title = "MobilePay Succeeded";
#if SILVERLIGHT
System.Windows.MessageBox.Show(message, title, System.Windows.MessageBoxButton.OK);
#else
var popup = new Windows.UI.Popups.MessageDialog(message, title);
await popup.ShowAsync();
#endif
}
protected void SendTextResult(string text)
{
EnsureAtMostOneResultSent();
var result = new SuccessResult() { Id = Id, ResultText = text};
result.Send(Configuration);
}
protected void SendSuccessResult()
{
var result = new SuccessResult() { Id = Id };
Send(result);
}
protected void SendSuccessResult()
{
EnsureAtMostOneResultSent();
var result = new SuccessResult() { Id = Id };
result.Send(Configuration);
}
public static SuccessResult GetSuccess(int exitCode,
TimeSpan timeElapsed,
IEnumerable<string> outputTextLines,
IEnumerable<string> warningTextLines,
string outputAssemblyFilepath)
{
if (outputTextLines == null)
throw new ArgumentNullException("outputTextLines");
if (warningTextLines == null)
throw new ArgumentNullException("warningTextLines");
if (string.IsNullOrWhiteSpace(outputAssemblyFilepath))
throw new ArgumentException("outputAssemblyFilepath is empty or null", "outputAssemblyFilepath");
var result = new SuccessResult();
result.IsSuccess = true;
result.ExiteCode = exitCode;
result.TimeElapsed = timeElapsed;
result.OutputTextLines = new List<string>(outputTextLines);
result.WarningTextLines = new List<string>(warningTextLines);
result.OutputAssemblyFilepath = outputAssemblyFilepath;
return result;
}
protected void SendTextResult(string text)
{
var result = new SuccessResult() { Id = Id, ResultText = text };
Send(result);
}
