/// <summary>
/// Loads the add pop up.
/// </summary>
/// <returns>returns _AddPopUp partial view</returns>
public async Task <ActionResult> LoadAddPopUp()
{
try
{
FeatureViewModel featureVM = new FeatureViewModel();
var categoryVMList = await GetAllCategories();
categoryVMList
.ForEach(c => c.Children = categoryVMList
.Where(x => x.ParentId == c.Id)
.OrderBy(x => x.SortOrder)
.ToList());
categoryVMList = categoryVMList
.Where(x => x.ParentId == 0 || x.ParentId == null)
.ToList();
featureVM.CategoryViewModelList = categoryVMList;
////return PartialView("_AddPopUp", featureVM);
return(Json(new
{
Status = 1,
Data = RenderRazorViewToString("_AddPopUp", featureVM),
Message = string.Empty
}));
}
catch (Exception ex)
{
logger.Error(ex.Message);
return(Json(new { Status = 0, Data = "error", Message = ex.Message }));
}
}
public static List <CustomReportFilterViewModel> GetUsedFiltersForReport(IUnitOfWork db, long reportId)
{
var query = from filter in db.CustomReportFilters.GetAllAsDto()
join predefinedField in db.CustomReportPredefinedFields.GetAllAsDto()
on filter.CustomReportPredefinedFieldId equals predefinedField.Id
where filter.CustomReportId == reportId
select new
{
Id = filter.Id,
PredefinedField = predefinedField,
Filter = filter,
//Field = field
};
var res = query.ToList().Select(x => new CustomReportFilterViewModel()
{
Id = x.Filter.Id,
Field = new CustomReportFieldViewModel(x.PredefinedField),
AvailableOperations = CustomReportService.GetOperations(x.PredefinedField.DataType).Select(y => new FilterOperationViewModel(y)).ToList(),
Operation = (FilterOperation)Enum.Parse(typeof(FilterOperation), x.Filter.Operation),
Value = GetObjectFromString(x.PredefinedField.DataType, x.Filter.Value),
PredefinedFieldId = x.PredefinedField.Id,
OperationString = EnumHelper <FilterOperation> .GetEnumDescription(x.Filter.Operation.ToString()),
Items = x.PredefinedField.DataType == "feature" ? FeatureViewModel.GetFeatureValuesByName(db, x.PredefinedField.Name) : new List <SelectListItemEx>(),
ValueTitle = x.PredefinedField.DataType == "feature" ? db.FeatureValues.Get((int)GetObjectFromString(x.PredefinedField.DataType, x.Filter.Value)).Value : null
});
return(res.ToList());
}
/// <summary>
/// Sets the feature view model.
/// </summary>
/// <param name="catergoryModel">The catergory model.</param>
/// <param name="featureModel">The feature model.</param>
/// <returns>FeatureViewModel object</returns>
private FeatureViewModel SetFeatureViewModel(List <CategoryViewModel> catergoryModel, List <FeatureViewModel> featureModel)
{
FeatureViewModel feature = new FeatureViewModel();
feature.CategoryViewModelList = new List <CategoryViewModel>();
List <CategoryViewModel> categoryList = new List <CategoryViewModel>();
try
{
List <CategoryViewModel> categoryListToAdd = MaptoCategory(catergoryModel, featureModel);
List <CategoryViewModel> subcategoryListToAdd = MaptoSubCategory(catergoryModel, featureModel);
foreach (var category in categoryListToAdd)
{
category.Children = new List <CategoryViewModel>();
foreach (var subcategoryItem in subcategoryListToAdd)
{
if (category.Id == subcategoryItem.ParentId)
{
category.Children.Add(subcategoryItem);
}
}
}
feature.CategoryViewModelList.AddRange(categoryListToAdd);
}
catch (Exception ex)
{
logger.Error(ex.Message);
return(null);
}
return(feature);
}
public async Task <IActionResult> AddFeature(FeatureViewModel model)
{
if (ModelState.IsValid)
{
var afc = new AddFeatureCommand()
{
Feature = new Feature()
{
Title = model.Title,
Description = model.Description
}
};
var result = await _cp.ProcessAsync(afc);
if (result.Succeeded)
{
return(RedirectToAction("ManageFeatures"));
}
else
{
// To do, better exeception handling
return(NotFound());
}
}
return(View(model));
}
public async Task <HttpResponseMessage> Get(byte id)
{
var result = await redisCache.GetAsync <FeatureViewModel>(id);
if (result == null)
{
List <string> list = new List <string> {
"Id"
};
var para = APIProvider.APIDefaultParameter(list, id);
var data = await _iFeatureRepo.SingleQuery(para);
result = new FeatureViewModel
{
Id = data.Id,
Title = data.Title,
Image = LayoutGuide.SPA_ResourcePath(Provider.Common.APIEnums.Application.CMS, data.Image),
Description = data.Description,
Handler = data.Handler,
IsUsed = data.IsUsed
};
//
await redisCache.AddAsync <FeatureViewModel>(result);
}
return(Request.CreateResponse(HttpStatusCode.OK, result));
}
public async Task <ActionResult> Delete(FeatureViewModel model)
{
try
{
if (!await APIProvider.Authorization(_userSession.BearerToken, ARS.Delete))
{
TempData["Alert"] = ApplicationGenerator.RenderResult(ApplicationGenerator.FuntionType.Article, APIConstant.ACTION_DELETE);
return(RedirectToAction("Index"));
}
else
{
return(PartialView("_Delete", model));
}
}
catch (HttpException ex)
{
Logger.LogError(ex);
int statusCode = ex.GetHttpCode();
if (statusCode == 401)
{
TempData["Alert"] = ApplicationGenerator.RenderResult(FuntionType.Department, APIConstant.ACTION_ACCESS);
return(new HttpUnauthorizedResult());
}
throw ex;
}
}
public async Task <ActionResult> Delete(byte id)
{
try
{
var model = new FeatureViewModel();
model.Id = id;
//Call API Provider - Transaction
string apiUrl = APIProvider.APIGenerator(controllerName, APIConstant.ACTION_DELETE);
var result = await APIProvider.Authorize_DynamicTransaction <FeatureViewModel, bool>(model, _userSession.BearerToken, apiUrl, APIConstant.API_Resource_CMS, ARS.IgnoredARS);
if (result)
{
TempData["Alert"] = ApplicationGenerator.RenderResult(ApplicationGenerator.TypeResult.SUCCESS, ApplicationGenerator.GeneralActionMessage(APIConstant.ACTION_DELETE, ApplicationGenerator.TypeResult.SUCCESS));
}
else
{
TempData["Alert"] = ApplicationGenerator.RenderResult(ApplicationGenerator.TypeResult.FAIL, ApplicationGenerator.GeneralActionMessage(APIConstant.ACTION_DELETE, ApplicationGenerator.TypeResult.FAIL));
}
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
Logger.LogError(ex);
return(RedirectToAction("Index"));
}
}
public async Task <ActionResult> Edit(FeatureViewModel model, HttpPostedFileBase fileUpload)
{
if (ModelState.IsValid)
{
if (fileUpload != null)
{
//model.Image = fileUpload.FileName;
string imgName = "";
FileManagement.UploadImage(fileUpload, ValueConstant.IMAGE_FEATURE_PATH, ref imgName);
model.Image = imgName;
}
//else
// model.Image = string.Empty;
//Call API Provider
string strUrl = APIProvider.APIGenerator(controllerName, APIConstant.ACTION_UPDATE);
var result = await APIProvider.Authorize_DynamicTransaction <FeatureViewModel, bool>(model, _userSession.BearerToken, strUrl, APIConstant.API_Resource_CMS, ARS.IgnoredARS);
if (result)
{
TempData["Alert"] = ApplicationGenerator.RenderResult(ApplicationGenerator.TypeResult.SUCCESS, ApplicationGenerator.GeneralActionMessage(APIConstant.ACTION_UPDATE, ApplicationGenerator.TypeResult.SUCCESS));
}
else
{
TempData["Alert"] = ApplicationGenerator.RenderResult(ApplicationGenerator.TypeResult.FAIL, ApplicationGenerator.GeneralActionMessage(APIConstant.ACTION_UPDATE, ApplicationGenerator.TypeResult.FAIL));
}
return(RedirectToAction("Index"));
}
else
{
TempData["Alert"] = ApplicationGenerator.RenderResult(ApplicationGenerator.TypeResult.FAIL, ApplicationGenerator.GeneralActionMessage(APIConstant.ACTION_UPDATE, ApplicationGenerator.TypeResult.FAIL));
return(View());
}
}
public void CreateFeature(FeatureViewModel featureViewModel)
{
var feature = Mapper.Map <FeatureViewModel, Feature_M>(featureViewModel);
_featureRepository.Add(feature);
SaveFeature();
}
public async Task <IActionResult> PutFeature(Guid?id, FeatureViewModel feature)
{
var mappedFeature = this.mapper.Map <Feature>(feature);
if (id != mappedFeature.Id)
{
return(BadRequest());
}
this.context.Entry(mappedFeature).State = EntityState.Modified;
try
{
await this.context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!FeatureExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
// GET: Feature
public async Task <ActionResult> Index()
{
try
{
var results = new FeatureModel();
//Call API Provider
controllerName = this.ControllerContext.RouteData.Values["controller"].ToString();
var list = await APIProvider.Authorize_Get <List <FeatureViewModel> >(_userSession.BearerToken, controllerName, APIConstant.API_Resource_CMS, ARS.Get);
var model = new FeatureViewModel();
results.lstFeatureViewModel = list;
results.FeatureViewModel = model;
return(View(results));
}
catch (HttpException ex)
{
Logger.LogError(ex);
int statusCode = ex.GetHttpCode();
if (statusCode == 401)
{
TempData["Alert"] = ApplicationGenerator.RenderResult(FuntionType.Department, APIConstant.ACTION_ACCESS);
return(new HttpUnauthorizedResult());
}
throw ex;
}
}
private void InitializeViews(int?feature_id, int?type_id)
{
Feature feature;
SelectList typesList;
User user = new UsersServices().GetByUserName(User.Identity.Name.ToString());
if (feature_id != null)
{
feature = _featureService.GetById((int)feature_id);
typesList = new SelectList(new FeedbackTypesServices().GetFeedbackTypesForDropDownList(), "Key", "Value", feature.FeedbackType_Id);
}
else
{
feature = new Feature();
if (type_id.HasValue)
{
feature.FeedbackType_Id = type_id.Value;
typesList = new SelectList(new FeedbackTypesServices().GetFeedbackTypesForDropDownList(), "Key", "Value", type_id.Value);
}
else
{
typesList = new SelectList(new FeedbackTypesServices().GetFeedbackTypesForDropDownList(), "Key", "Value");
}
}
_featureViewModel = new FeatureViewModel(feature, typesList);
}
public async Task OnGetAsync()
{
FeatureCategories = new List <FeatureCategoryViewModel>();
Users = await DataContext.AppUsers.ToListAsync();
BaseScoreModifiers = await DataContext.HomeReviewBaseScoreModifiers.ToListAsync();
foreach (var category in DataContext.HomeReviewFeatureCategories.Include(r => r.Features).OrderBy(r => r.SortOrder))
{
var categoryViewModel = new FeatureCategoryViewModel {
Id = category.Id,
Title = category.Title,
Features = new List <FeatureViewModel>()
};
FeatureCategories.Add(categoryViewModel);
foreach (var detail in category.Features.OrderBy(r => r.SortOrder))
{
var detailViewModel = new FeatureViewModel {
Id = detail.Id,
Title = detail.Title,
Weights = new List <FeatureWeightViewModel>()
};
categoryViewModel.Features.Add(detailViewModel);
}
}
}
// GET: Features/Details/5
public async Task <ActionResult> Details(long?id)
{
try
{
if (id == null)
{
return(RedirectToAction(nameof(Index)));
}
var viewModel = new FeatureViewModel
{
PageHeader = new PageHeaderViewModel
{
Title = "Feature Details",
PageLink = $"/admin/features/details/{id}",
Target = "/admin/features/",
CreatePage = "/admin/features/create"
}
};
var response = await _httpService.Api.GetAsync($"/api/features/{id}");
if (!response.IsSuccessStatusCode)
{
return(RedirectToAction(nameof(Index)).NotifyBadRequest());
}
viewModel.Feature = await response.Content.ReadAsJsonAsync <FeatureDto>();
return(View(viewModel));
}
catch (Exception ex)
{
return(RedirectToAction(nameof(Index)).NotifyError(ex.Message));
}
}
public async Task <FeatureViewModel> CreateFeature([FromBody] FeatureViewModel featureVM)
{
var domainModel = featureVM.ToDomainModel();
if (featureVM.FeatureId > 0) // editing an existing feature
{
//make sure they're the author of this feature
var existingFeature = await this.dbCtx.Features.FirstOrDefaultAsync(f => f.Player.Id == userSession.Player.Id && f.Id == featureVM.FeatureId);
if (existingFeature != null)
{
//yep, it's theirs
existingFeature.Delisted = true;
}
}
domainModel.Id = 0;
domainModel.RequiredFlaws.ForEach(f => dbCtx.Attach(f));
domainModel.RequiredOaths.ForEach(o => dbCtx.Attach(o));
dbCtx.Attach(userSession.Player);
domainModel.Player = userSession.Player;
domainModel.CreatedAtMS = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
dbCtx.Features.Add(domainModel);
await dbCtx.SaveChangesAsync();
domainModel.Player = userSession.Player;
return(domainModel.ToViewModel());
}
public async Task <ActionResult> Create(FeatureViewModel viewModel)
{
try
{
viewModel.PageHeader = new PageHeaderViewModel
{
Title = "Features",
FormName = "addFeatureForm",
Target = "/admin/features/"
};
if (!TryValidateModel(viewModel.Feature))
{
return(View(viewModel).NotifyValidationError());
}
var response = await _httpService.Api.PostAsJsonAsync("/api/features", viewModel.Feature);
if (!response.IsSuccessStatusCode)
{
return(View(viewModel).NotifyBadRequest());
}
return(RedirectToAction(nameof(Index)).NotifySaved());
}
catch (Exception ex)
{
return(View(viewModel).NotifyError(ex.Message));
}
}
// GET: Features
public async Task <IActionResult> Index(FeatureViewModel viewModel)
{
try
{
viewModel.PageHeader = new PageHeaderViewModel
{
Title = "Features",
PageLink = "/admin/features/",
CreatePage = "/admin/features/create"
};
var response = await _httpService.Api.GetAsync("/api/features");
if (!response.IsSuccessStatusCode)
{
return(RedirectToAction("Index", "Home").NotifyBadRequest());
}
viewModel.Features = await response.Content.ReadAsJsonAsync <List <FeatureDto> >();
// Reading coockies demo
// todo remove
var json = Request.Cookies[Constant.AuthData];
var authdata = JsonConvert.DeserializeObject <AuthReturnDto>(json);
return(View(viewModel));
}
catch (Exception ex)
{
return(RedirectToAction("Index", "Home").NotifyError(ex.Message));
}
}
void ValidateRequest(FeatureViewModel model)
{
if (String.IsNullOrEmpty(model.Title))
{
ModelState.AddModelError("title", "請填寫標題");
}
}
public FeaturedVehiclesViewModel GetAllFeatures()
{
FeaturedVehiclesViewModel featured = new FeaturedVehiclesViewModel();
using (SqlConnection conn = new SqlConnection())
{
conn.ConnectionString = _connection;
SqlCommand cmd = new SqlCommand();
cmd.Connection = conn;
cmd.CommandText = "GetAllFeatures";
cmd.CommandType = CommandType.StoredProcedure;
conn.Open();
using (SqlDataReader dr = cmd.ExecuteReader())
{
while (dr.Read())
{
FeatureViewModel current = new FeatureViewModel();
current.VehicleId = (int)dr["VehicleId"];
current.YearMakeModel = dr["YearMakeModel"].ToString();
current.SalePrice = (decimal)dr["SalePrice"];
featured.features.Add(current);
}
}
}
return(featured);
}
public ActionResult Calculate(FeatureViewModel model)
{
if (!ModelState.IsValid)
{
return(View("~/Views/Home/Score.cshtml", model));
}
//average score calculation
var allscore_list = _context.Scores.Where(b => b.HumanId == AnswerData.human_id).Select(x => x.FinalScore).ToList();
double score_average = allscore_list.Average();
//difficulty calculation
_context.Humen.Find(AnswerData.human_id).AverageScore = score_average;
var userid = User.Identity.GetUserId();
_context.Scores.Where(x => x.HumanId == AnswerData.human_id && x.ApplicationUserId == userid).FirstOrDefault().Difficulty = model.Difficulty;
_context.SaveChanges();
var difficulty_list = _context.Scores.Where(z => z.HumanId == AnswerData.human_id).Select(z => z.Difficulty).ToList();
double difficulty_average = difficulty_list.Average();
_context.Humen.Find(AnswerData.human_id).Difficulty = difficulty_average;
//popularity calculation
var user_number = _context.Users.Count() - 1;
var user_played_that_human = _context.Scores.Where(x => x.HumanId == AnswerData.human_id).ToList().Count();
double popularity = ((double)user_played_that_human / (double)user_number) * 100;
_context.Humen.Find(AnswerData.human_id).Popularity = popularity;
_context.SaveChanges();
return(RedirectToAction("Index", "Home"));
}
public async Task <IActionResult> AssignFeatures(RoleViewModel viewModel)
{
if (viewModel.SelectedControllers != null && viewModel.SelectedControllers.Any())
{
var featuresList = new List <FeatureViewModel>();
var features = await _helper.GetFeaturesAsync();
foreach (var controller in viewModel.SelectedControllers)
{
foreach (var action in controller.Actions)
{
var feature = new FeatureViewModel();
feature.Name = action.DisplayName;
featuresList.Add(feature);
}
}
List <int> featureId = new List <int>();
foreach (var item in features)
{
foreach (var newitem in featuresList)
{
if (item.Name == newitem.Name)
{
featureId.Add(item.Id);
}
}
}
await _helper.CreateRoleFeatureListAsync(viewModel.Id, featureId);
}
return(RedirectToAction("Show"));
}
public async Task <ActionResult> ListFeatures(FeatureParameters parameters)
{
ValidateFeatureParameters(parameters, FeatureParametersValidator.NoValidation);
var filter = new FeatureFilter()
{
FilterMessage = parameters.FilterMessage,
CarLine = parameters.CarLine,
ModelYear = parameters.ModelYear,
Gateway = parameters.Gateway,
Action = FeatureAction.Features
};
filter.InitialiseFromJson(parameters);
var results = await FeatureViewModel.GetModel(DataContext, filter);
var jQueryResult = new JQueryDataTableResultModel(results);
foreach (var result in results.Features.CurrentPage)
{
jQueryResult.aaData.Add(result.ToJQueryDataTableResult());
}
return(Json(jQueryResult));
}
public async Task <IActionResult> EditFeature(FeatureViewModel model)
{
if (ModelState.IsValid)
{
var efc = new EditFeatureCommand()
{
Id = model.Id,
NewTitle = model.Title,
NewDescription = model.Description
};
var result = await _cp.ProcessAsync(efc);
if (result.Succeeded)
{
return(RedirectToAction("ManageFeatures"));
}
else
{
// To Do - Better Error handling
return(NotFound());
}
}
return(View(model));
}
public async Task <IActionResult> OnGetAsync(string id)
{
if (id?.Length > 0)
{
AppUser = await DataContext.AppUsers.FindAsync(id);
if (AppUser is null)
{
return(NotFound());
}
}
else
{
AppUser = await AppUsers.Get(User);
}
FeatureCategories = new List <FeatureCategoryViewModel>();
foreach (var featureCategory in DataContext.HomeReviewFeatureCategories.Include(r => r.Features).ThenInclude(r => r.FeatureChoices).OrderBy(r => r.SortOrder))
{
var featureCategoryViewModel = new FeatureCategoryViewModel {
Title = featureCategory.Title,
Features = new List <FeatureViewModel>()
};
FeatureCategories.Add(featureCategoryViewModel);
foreach (var feature in featureCategory.Features.OrderBy(r => r.SortOrder))
{
var featureUserWeight = await DataContext.HomeReviewUserWeights.FirstOrDefaultAsync(r => r.UserId == AppUser.Id && r.FeatureId == feature.Id);
var featureViewModel = new FeatureViewModel {
Title = feature.Title,
FeatureId = feature.Id,
Value = featureUserWeight?.Weight,
FeatureChoices = new List <FeatureChoiceViewModel>()
};
featureCategoryViewModel.Features.Add(featureViewModel);
var choices = await DataContext.HomeReviewFeatureChoices.Where(r => r.FeatureId == feature.Id).OrderBy(o => o.SortOrder).ToListAsync();
foreach (var choice in choices)
{
var featureChoiceUserWeight = await DataContext.HomeReviewUserWeights.FirstOrDefaultAsync(r => r.UserId == AppUser.Id && r.FeatureChoiceId == choice.Id);
var featureChoiceViewModel = new FeatureChoiceViewModel {
Title = choice.Title,
FeatureChoiceId = choice.Id,
Value = featureChoiceUserWeight?.Weight
};
featureViewModel.FeatureChoices.Add(featureChoiceViewModel);
}
}
}
return(Page());
}
public async Task <ActionResult <FeatureViewModel> > PostFeature(FeatureViewModel feature)
{
var mappedFeature = this.mapper.Map <Feature>(feature);
this.context.Features.Add(mappedFeature);
await this.context.SaveChangesAsync();
return(CreatedAtAction("GetFeature", new { id = feature.Id }, feature));
}
public async Task DeleteAsync(int packetId, FeatureViewModel feature)
{
await _featureRepo.deleteAsync(
new Feature {
Id = feature.id,
Description = feature.Description,
PacketId = packetId
});
}
public async Task <ActionResult> Create(FeatureViewModel model, HttpPostedFileBase fileUpload)
{
try
{
if (fileUpload == null)
{
ModelState.AddModelError("Image", "Vui lòng chọn hình ảnh");
}
if (ModelState.IsValid)
{
if (fileUpload != null)
{
//model.Image = fileUpload.FileName;
string imgName = "";
FileManagement.UploadImage(fileUpload, ValueConstant.IMAGE_FEATURE_PATH, ref imgName);
model.Image = imgName;
}
//Call API Provider
string strUrl = APIProvider.APIGenerator(controllerName, APIConstant.ACTION_INSERT);
var result = await APIProvider.Authorize_DynamicTransaction <FeatureViewModel, bool>(model, _userSession.BearerToken, strUrl, APIConstant.API_Resource_CMS, ARS.Insert);
if (result)
{
TempData["Alert"] = ApplicationGenerator.RenderResult(ApplicationGenerator.TypeResult.SUCCESS, ApplicationGenerator.GeneralActionMessage(APIConstant.ACTION_INSERT, ApplicationGenerator.TypeResult.SUCCESS));
}
else
{
TempData["Alert"] = ApplicationGenerator.RenderResult(ApplicationGenerator.TypeResult.FAIL, ApplicationGenerator.GeneralActionMessage(APIConstant.ACTION_INSERT, ApplicationGenerator.TypeResult.FAIL));
}
return(RedirectToAction("Index"));
}
else
{
var feature = new FeatureModel();
feature.lstFeatureViewModel = await APIProvider.Get <List <FeatureViewModel> >(controllerName);
feature.FeatureViewModel = model;
TempData["Alert"] = ApplicationGenerator.RenderResult(ApplicationGenerator.TypeResult.FAIL, ApplicationGenerator.GeneralActionMessage(APIConstant.ACTION_INSERT, ApplicationGenerator.TypeResult.FAIL));
return(View("Index", feature));
}
}
catch (HttpException ex)
{
Logger.LogError(ex);
int statusCode = ex.GetHttpCode();
if (statusCode == 401)
{
TempData["Alert"] = ApplicationGenerator.RenderResult(FuntionType.Department, APIConstant.ACTION_ACCESS);
return(new HttpUnauthorizedResult());
}
throw ex;
}
}
public async Task <ActionResult> FeaturePage(FeatureParameters parameters)
{
var filter = new FeatureFilter()
{
PageIndex = PageIndex,
PageSize = PageSize
};
return(View(await FeatureViewModel.GetModel(DataContext, filter)));
}
public async Task <ActionResult> EditFeature(Guid tenderGuid, string featureId)
{
var tender = await DraftProvider.GetDraftTender(tenderGuid);
var feature = await DraftProvider.GetDraftFeature(tenderGuid, featureId);
var viewModel = new FeatureViewModel(tenderGuid, feature);
return(View(viewModel));
}
public async Task <FeatureViewModel> UpdateAsync(int packetId, FeatureViewModel feature)
{
await _featureRepo.updateAsync(
new Feature {
Id = feature.id,
Description = feature.Description,
PacketId = packetId
});
return(feature);
}
