private void ValidateFeature(FeatureDto featureDto, long adminId)
{
foreach (var featureName in featureDto.FeatureNameDictionary)
{
if (string.IsNullOrEmpty(featureName.Value))
{
throw new ValidationException(ErrorCodes.EmptyFeatureName);
}
if (featureName.Value.Length > 300)
{
throw new ValidationException(ErrorCodes.FeatureNameExceedLength);
}
if (_featureTranslationService.CheckFeatureNameExist(featureName.Value, featureName.Key, featureDto.FeatureId, adminId)
)
{
throw new ValidationException(ErrorCodes.FeatureNameAlreadyExist);
}
}
//foreach (var featureDetail in featureDto.FeatureDetails)
//{
// foreach (var description in featureDetail.DescriptionDictionary)
// {
// if (string.IsNullOrEmpty(description.Value))
// throw new ValidationException(ErrorCodes.EmptyFeatureName);
// if (description.Value.Length > 300)
// throw new ValidationException(ErrorCodes.FeatureNameExceedLength);
// if (_featureDetailTranslationService.CheckFeatureDetailDescriptionExist(description.Value, description.Key, featureDetail.FeatureDetailId, adminId)
// ) throw new ValidationException(ErrorCodes.FeatureNameAlreadyExist);
// }
//}
}
public void Post()
{
try
{
using (var server = TestServer.Create <MyStartup>())
{
var dto = new FeatureDto
{
Id = 0,
ClinicalCategoryId = 1,
GroupId = 1,
TypeId = 1,
Name = "feature 9",
Description = "F 1",
Items = new List <FeatureItemDto>
{
new FeatureItemDto {
ItemId = 2, FeatureId = 0, UpdatedOn = DateTime.Now, CreatedOn = DateTime.Now
}
}
};
HttpResponseMessage response;
response = server.HttpClient.PostAsJsonAsync("api/Feature/Items", dto).Result;
}
}
catch (Exception ex)
{
}
}
public bool IsEnabled(string name, FeatureDto feature)
{
var evaluators = FeatureBeeBuilder.Context.Evaluators;
var isFulfilled = false;
foreach (var condition in feature.Conditions)
{
var evaluator = evaluators.FirstOrDefault(x => string.Equals(x.Name, condition.Type));
if (evaluator == null)
{
return(false);
}
isFulfilled = evaluator.IsFulfilled(condition.Values.ToArray());
if (isFulfilled)
{
continue;
}
Logger.Log(TraceEventType.Verbose, "Feature {0} does not fulfill condition {1} of type {2}", feature.Name, condition.Values, condition.Type);
return(false);
}
return(isFulfilled);
}
public async Task <IActionResult> UpdateFeatureById(long featureId, FeatureDto featureDto)
{
try
{
if (featureId != featureDto.Id)
{
return(BadRequest());
}
var feature = await _featureService.GetFeatureById(featureId);
if (feature == null)
{
return(NotFound());
}
var status = feature.Status;
_mapper.Map(featureDto, feature);
feature.Status = status;
_featureService.UpdateFeature(featureId, feature);
await _unitOfWork.Save();
return(NoContent());
}
catch (Exception)
{
return(BadRequest());
}
}
public FeatureDto CreateFeature(FeatureDto FeatureDto, int userId, int tenantId, MemoryStream files, string path)
{
if (GetFeature(FeatureDto.FeatureId, tenantId) != null)
{
return(EditFeature(FeatureDto, userId, tenantId, files, path));
}
ValidateFeature(FeatureDto, tenantId);
var FeatureObj = Mapper.Map <Feature>(FeatureDto);
foreach (var FeatureName in FeatureDto.TitleDictionary)
{
FeatureObj.FeaturesTranslations.Add(new FeatureTranslation
{
Title = FeatureName.Value,
Language = FeatureName.Key,
});
}
FeatureObj.CreationTime = Strings.CurrentDateTime;
FeatureObj.CreatorUserId = userId;
FeatureObj.TenantId = tenantId;
_typeTranslationService.InsertRange(FeatureObj.FeaturesTranslations);
_featureService.Insert(FeatureObj);
SaveChanges();
_manageStorage.UploadImage(path + "\\" + "Feature-" + FeatureObj.FeatureId, files, FeatureObj.FeatureId.ToString());
return(FeatureDto);
}
public FeatureDto ConvertFeatureToDto(Feature feature)
{
var pointDto = new PointDto(
feature.Geometry.Coordinate.X,
feature.Geometry.Coordinate.Y);
var address = feature.Attributes["address"].ToString();
var attributesNames = feature.Attributes.GetNames();
string name = string.Empty;
if (attributesNames.Contains("name"))
{
name = feature.Attributes["name"].ToString();
}
string category = string.Empty;
if (attributesNames.Contains("category"))
{
category = feature.Attributes["category"].ToString();
}
var featureDto = new FeatureDto(
address,
name,
category,
pointDto);
return(featureDto);
}
public void AddFeature(FeatureDto featureDto, long adminId, string path)
{
var user = _userService.Find(adminId);
if (user == null)
{
throw new NotFoundException(ErrorCodes.UserNotFound);
}
ValidateFeature(featureDto, adminId);
var feature = Mapper.Map <Feature>(featureDto);
feature.CreationBy = adminId;
feature.CreateTime = DateTime.Now;
feature.IsActive = true;
foreach (var featureControlDto in featureDto.FeatureControl)
{
feature.FeatureControls.Add(new FeatureControl
{
Control = featureControlDto.Control,
ControlType =
featureControlDto.Control == Enums.Control.ListOfText ||
featureControlDto.Control == Enums.Control.ListOfTextAndImage ||
featureControlDto.Control == Enums.Control.ListOfAvailable
? Enums.ControlType.Single
: Enums.ControlType.None,
Order = featureControlDto.Order,
IsActive = true
});
}
//foreach (var featureName in featureDto.FeatureNameDictionary)
//{
// feature.FeatureTranslations.Add(new FeatureTranslation
// {
// FeatureName = featureName.Value,
// Language = featureName.Key.ToLower()
// });
//}
//feature.FeatureDetails.ForEach(x =>
//{
// x.CreationBy = adminId;
// x.CreateTime = DateTime.Now;
//});
//feature.FeatureDetails.ForEach(x => _featureDetailTranslationService.InsertRange(x.FeatureDetailTranslations));
//_featureDetailService.InsertRange(feature.FeatureDetails);
_featureControlService.InsertRange(feature.FeatureControls);
_featureTranslationService.InsertRange(feature.FeatureTranslations);
_featureService.Insert(feature);
foreach (var restaurantDto in featureDto.Restaurants)
{
var restaurant = _restaurantService.Find(restaurantDto.RestaurantId);
restaurant.Feature = feature;
_restaurantService.Update(restaurant);
}
SaveChanges();
_manageStorage.UploadImage(path + "\\" + "Feature-" + feature.FeatureId, featureDto.Image, feature.FeatureId.ToString());
}
public bool IsEnabled(string featureName, FeatureDto feature)
{
var godMode = this.godModeFeatures.First(x => x.Key.Equals(featureName, StringComparison.InvariantCultureIgnoreCase));
Logger.Log(TraceEventType.Verbose, "Feature {0} overwritten by GodMode. Value is {1}", featureName, godMode.Value);
return(godMode.Value);
}
public string BuildFullReport(FeatureDto featureDto)
{
StringBuilder sb = new StringBuilder("<html>");
sb.Append(GetScenarioInfo(featureDto));
sb.Append("</html>");
return(sb.ToString());
}
public string BuildScenarioReport(FeatureDto featureDto)
{
StringBuilder sb = new StringBuilder("<html>");
sb.Append("<body>");
sb.Append($"<h2>Feature: {featureDto.Title}<h2>");
sb.Append($"<p>{featureDto.Description}</p>");
sb.Append($"<h3>Tags:</h3>");
sb.Append($"<ol>");
foreach (string tag in featureDto.Tags)
{
sb.Append($"<li>{tag}<li>");
}
sb.Append("</ol>");
sb.Append($"<table>");
sb.Append($"<tbody>");
foreach (ScenarioDto scenario in featureDto.Scenarios.Values)
{
sb.Append($"<tr>");
sb.Append(
$"<td style='border:1px solid black;'>" +
$"<h1><strong>{scenario.Title}</strong></h1>" +
$"<table>");
foreach (StepDto step in scenario.Steps)
{
sb.Append($"<tr><td>{step.Title}</td></tr>");
}
sb.Append($"</table>");
if (scenario.ExecutionStatus == "TestError")
{
sb.Append($"<strong style='color: red;'>Execution Status: {scenario.ExecutionStatus}</strong></br>");
sb.Append($"<strong style='color: red;'>Error: {scenario.TestError.Message}</strong></br>");
}
else
{
sb.Append($"<strong>Execution Status: {scenario.ExecutionStatus}</strong></br>");
}
if (scenario.Screenshots != null)
{
sb.Append($"<p><h1>Screenshots</h1></p>" +
$"<p>");
foreach (KeyValuePair <string, string> entry in scenario.Screenshots)
{
sb.Append($"{entry.Key}<img src='{entry.Value}'>");
}
sb.Append($"</p>");
}
sb.Append($"</td>");
sb.Append($"</tr>");
}
sb.Append($"</tbody>");
sb.Append($"</table>");
sb.Append("</body>");
sb.Append("</html>");
return(sb.ToString());
}
protected virtual async Task OnFeatureValueChangedAsync(string value, FeatureDto feature)
{
if (feature?.ValueType?.Validator.IsValid(value) == true)
{
feature.Value = value;
}
else
{
await UiMessageService.Warn(L["Volo.Abp.FeatureManagement:InvalidFeatureValue", feature.DisplayName]);
}
}
protected virtual void SetFeatureDepth(List <FeatureDto> features, string providerName, string providerKey,
FeatureDto parentFeature = null, int depth = 0)
{
foreach (var feature in features)
{
if ((parentFeature == null && feature.ParentName == null) || (parentFeature != null && parentFeature.Name == feature.ParentName))
{
feature.Depth = depth;
SetFeatureDepth(features, providerName, providerKey, feature, depth + 1);
}
}
}
public static Feature ToFeature(this FeatureDto dto)
{
if (dto == null)
{
return(null);
}
Feature entity = new Feature();
entity.CopyPropertiesFrom(dto);
return(entity);
}
public static FeatureDto ToFeatureDto(this Feature entity)
{
if (entity == null)
{
return(null);
}
FeatureDto dto = new FeatureDto();
dto.CopyPropertiesFrom(entity);
return(dto);
}
private NameValue GetValueName(FeatureDto featureDto)
{
if (featureDto.Selected)
{
return(new NameValue(featureDto.Name, featureDto.DefaultValue));
}
if (!(featureDto.InputType is SingleLineStringInputType))
{
return(new NameValue(featureDto.Name, DefaultBooleanValue));
}
var feature = _editionManager.FeatureManager.GetOrNull(featureDto.Name);
return(new NameValue(featureDto.Name, feature.DefaultValue));
}
private void ValidateFeature(FeatureDto FeatureDto, long tenantId)
{
foreach (var name in FeatureDto.TitleDictionary)
{
if (name.Value.Length > 300)
{
throw new ValidationException(ErrorCodes.MenuNameExceedLength);
}
if (_typeTranslationService.CheckNameExist(name.Value, name.Key, FeatureDto.FeatureId, tenantId))
{
throw new ValidationException(ErrorCodes.NameIsExist);
}
}
}
protected virtual Task OnSelectedValueChangedAsync(bool value, FeatureDto feature)
{
ToggleValues[feature.Name] = value;
if (value)
{
CheckParents(feature.ParentName);
}
else
{
UncheckChildren(feature.Name);
}
return(Task.CompletedTask);
}
private FeatureDto BuildFeatureDto()
{
var feature = new FeatureDto
{
Title = "QM-Handbuch",
SubTitle = "DEVPERTS GmbH i. Gr.",
Summary = "Qualitätsmanagement",
Url = Url.RouteUrl(nameof(QualityManagementController) + "." + nameof(QualityManagementController.GetTopLevelElements)),
Color = "pumpkin",
Icon = "dv-tags",
Description = "Handbuch für Qualitätsmanagement"
};
return(feature);
}
private FeatureDto BuildFeatureDto()
{
var feature = new FeatureDto
{
Title = "Vacation Process",
SubTitle = "Example of d.velop cloud platform integration",
Summary = "Extend the d.velop cloud platform",
Url = Url.RouteUrl(nameof(VacationRequestController) + "." + nameof(VacationRequestController.GetVacationListView)),
Color = "pumpkin",
Icon = "dv-tags",
Description = "Learn to create a d.ecs architecture application for extending the d.velop cloud platform."
};
return(feature);
}
public async Task <IActionResult> AddFeature(FeatureDto featureDto)
{
try
{
var feature = _mapper.Map <Feature>(featureDto);
feature.Status = Status.Authorized;
_featureService.AddFeature(feature);
await _unitOfWork.Save();
return(Ok(feature));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public static void SetUpFeature(FeatureContext featureContext, TestContext testContext)
{
var featureTitle = featureContext.FeatureInfo.Title;
var reportPath = featureTitle.Length > 30 ? featureTitle.Substring(0, 30) : featureTitle;
FeatureDto featureDto = new FeatureDto
{
Title = featureTitle,
Description = featureContext.FeatureInfo.Description,
Tags = featureContext.FeatureInfo.Tags,
ReportPath = testContext.OutputFilePath($"{reportPath}.html"),
ReportDirectory = testContext.UniqueOutputDirectory,
Scenarios = new Dictionary <string, ScenarioDto>()
};
featureContext.Set(featureDto);
}
public ActionResult Index()
{
FeatureDto featureDto = new FeatureDto();
featureDto.feature = db.ChatFeatureList.ToList();
featureDto.subfeature = db.ChatSubFeatureList.ToList();
featureDto.FeaturesDeveloped = featureDto.subfeature.Where(x => x.DevelopmentComplete).Count();
if (featureDto.subfeature.Where(x => x.EffortActual > 0).Any())
{
featureDto.ActualHrs = featureDto.subfeature.Select(x => x.EffortActual).ToList().Sum();
}
else
{
featureDto.ActualHrs = 0;
}
return(View(featureDto));
}
public static FeatureDto ToDto(this Feature feature, bool cascade = true)
{
var dto = new FeatureDto
{
Name = feature.Name,
Description = feature.Description,
WaitingPeriod = feature.WaitingPeriod,
IsMentalHealthWaiver = feature.IsMentalHealthWaiver,
IsActive = feature.IsActive,
IsDeleted = feature.IsDeleted,
TypeId = feature.TypeId,
GroupId = feature.GroupId,
ClinicalCategoryId = feature.ClinicalCategoryId ?? 0,
ClinicalCategory = feature.ClinicalCategory?.ToDto(false),
Items = feature.Items?.Select(v => v.ToDto()).ToList(),
};
((IData)feature).ToDto((IDataDto)dto);
return(dto);
}
public FeatureDto EditFeature(FeatureDto FeatureDto, int userId, int tenantId, MemoryStream files, string path)
{
var FeatureObj = _featureService.Query(x => x.FeatureId == FeatureDto.FeatureId && x.TenantId == tenantId).Select().FirstOrDefault();
if (FeatureObj == null)
{
throw new NotFoundException(ErrorCodes.ProductNotFound);
}
ValidateFeature(FeatureDto, tenantId);
foreach (var FeatureName in FeatureDto.TitleDictionary)
{
var FeatureTranslation = FeatureObj.FeaturesTranslations.FirstOrDefault(x => x.Language.ToLower() == FeatureName.Key.ToLower() &&
x.FeatureId == FeatureDto.FeatureId);
if (FeatureTranslation == null)
{
FeatureObj.FeaturesTranslations.Add(new FeatureTranslation
{
Title = FeatureName.Value,
Language = FeatureName.Key
});
}
else
{
FeatureTranslation.Title = FeatureName.Value;
}
}
FeatureObj.LastModificationTime = Strings.CurrentDateTime;
FeatureObj.LastModifierUserId = userId;
FeatureObj.IsDeleted = FeatureDto.IsDeleted;
_featureService.Update(FeatureObj);
SaveChanges();
if (files != null)
{
_manageStorage.UploadImage(path + "\\" + "Feature-" + FeatureObj.FeatureId, files, FeatureObj.FeatureId.ToString());
}
return(FeatureDto);
}
public static Feature ToDomain(this FeatureDto feature, Feature originalFeature = null)
{
//feature.Items?.ForEach(v => v.FeatureId = feature.Id);
if (originalFeature != null && originalFeature.Id == feature.Id)
{
originalFeature.Name = feature.Name;
originalFeature.Description = feature.Description;
originalFeature.WaitingPeriod = feature.WaitingPeriod;
originalFeature.IsMentalHealthWaiver = feature.IsMentalHealthWaiver;
originalFeature.IsActive = feature.IsActive;
originalFeature.IsDeleted = feature.IsDeleted;
originalFeature.TypeId = feature.TypeId;
originalFeature.GroupId = feature.GroupId;
originalFeature.ClinicalCategoryId = feature.ClinicalCategoryId != 0 ? feature.ClinicalCategoryId : (int?)null;
// originalFeature.Items?.Select(v => v.ToDto()).ToList();
((IDataDto)feature).ToDomain((IData)originalFeature);
return(originalFeature);
}
var data = new Feature
{
Name = feature.Name,
Description = feature.Description,
WaitingPeriod = feature.WaitingPeriod,
IsMentalHealthWaiver = feature.IsMentalHealthWaiver,
IsActive = feature.IsActive,
IsDeleted = feature.IsDeleted,
TypeId = feature.TypeId,
GroupId = feature.GroupId,
ClinicalCategoryId = feature.ClinicalCategoryId != 0 ? feature.ClinicalCategoryId : (int?)null,
//Items = feature.Items?.Select(v => v.ToDomain()).ToList()
};
((IDataDto)feature).ToDomain((IData)data);
return(data);
}
public string AddScenarioToFullReport(string fullReport, FeatureDto featureDto)
{
StringBuilder sb = new StringBuilder(fullReport[0..^ 7]);
public bool IsEnabled(string name, FeatureDto feature)
{
Logger.Log(TraceEventType.Verbose, "Feature {0} is 'Released'", feature.Name);
return(true);
}
protected virtual string GetFeatureStyles(FeatureDto feature)
{
return($"margin-left: {feature.Depth * 20}px");
}
public bool CanEvalute(string name, FeatureDto feature)
{
return(feature != null && feature.State == "Released");
}
public bool CanEvalute(string name, FeatureDto feature)
{
return(feature != null && feature.State == "In Development" && !FeatureBeeBuilder.Context.IsDebugMode);
}
