public void Test_IsPositionBlocked_PositionIsFree_ReturnsFalse()
{
var field = new Color?[, ] {
{ null }
};
var subject = new FieldHelper();
var vector = new Vector2(0, 0);
Assert.That(subject.IsPositionBlocked(vector, field), Is.False);
}
public void Test_IsPositionOutOfField_PositionIsOutOfField_ReturnsTrue()
{
var field = new Color?[, ] {
{ null }
};
var subject = new FieldHelper();
var position = new Vector2(-1, -1);
Assert.That(subject.IsPositionOutOfField(position, field), Is.True);
}
public void Test_IsPositionOutOfField_PositionIsNotOutOfField_ReturnsFalse()
{
var field = new Color?[, ] {
{ null }
};
var subject = new FieldHelper();
var position = new Vector2(0, 0);
Assert.That(subject.IsPositionOutOfField(position, field), Is.False);
}
public void TestSearchMultipleSearchConditionUsing1Field(Enums.ResourceType resourceType, string fieldName, List <string> fieldValues, string condition1, string condition2)
{
string resourceName = resourceType.ToResourceName();
string fieldAlias = $"{resourceName}.{fieldName}";
Dictionary <string, string> parameters = FieldHelper.CreateOneFieldSearchInstance(records, cleaner, resourceType, fieldAlias, fieldValues, condition1, condition2);
//Read & verify the field's value
DateTimeValidator.VerifySearchDate(resourceType, parameters);
}
public void Run(string then)
{
var fields = FieldHelper.GetFields(GetType());
fields[typeof(given)].ToList().ForEach(x => ((given)x.GetValue(this)).Invoke());
fields[typeof(when)].ToList().ForEach(x => ((when)x.GetValue(this)).Invoke());
var currentThen = (then)fields[typeof(then)].First(x => x.Name == then).GetValue(this);
currentThen.Invoke();
}
public void Test_IsPositionBlocked_PositionIsBlocked_ReturnsTrue()
{
var field = new Color?[, ] {
{ Color.Red }
};
var subject = new FieldHelper();
var vector = new Vector2(0, 0);
Assert.That(subject.IsPositionBlocked(vector, field), Is.True);
}
private void FormTransferFields_Load(object sender, EventArgs e)
{
FieldCollection fl = FieldHelper.GetAllFields();
foreach (Field field in fl)
{
comboBoxSourceField.Items.Add(new ComboBoxItem(dataBase, field));
}
UpdateWindowState();
}
private LoginUserFormFields GetFormFields(LoginUserData data, FormSubmitContext formSubmitContext)
{
Assert.ArgumentNotNull(data, nameof(data));
Assert.ArgumentNotNull(formSubmitContext, nameof(formSubmitContext));
return(new LoginUserFormFields
{
Username = FieldHelper.GetFieldById(data.UserNameFieldId, formSubmitContext.Fields),
Password = FieldHelper.GetFieldById(data.PasswordFieldId, formSubmitContext.Fields)
});
}
public void TestSearchOrderField(Enums.ResourceType resourceType, List <string> fieldValues, string order)
{
//Check registered application field
FieldHelper.CheckRegisteredField(readFields, resourceType, fieldsName.First());
FieldHelper.CheckRegisteredField(readFields, resourceType, fieldsName.Last());
List <WriteResultItem> ids = FieldHelper.CreateOrderInstance(records, cleaner, resourceType, fieldsName, fieldValues);
//Read & verify the field's value
DateTimeValidator.VerifyOrderFieldDate(resourceType, fieldsName, fieldValues, order, ids);
}
private RegisterUserFormFields GetFormFields(RegisterUserData data, FormSubmitContext formSubmitContext)
{
Assert.ArgumentNotNull(data, nameof(data));
Assert.ArgumentNotNull(formSubmitContext, nameof(formSubmitContext));
return(new RegisterUserFormFields
{
Email = FieldHelper.GetFieldById(data.EmailFieldId, formSubmitContext.Fields),
Password = FieldHelper.GetFieldById(data.PasswordFieldId, formSubmitContext.Fields),
FullName = FieldHelper.GetFieldById(data.FullNameFieldId, formSubmitContext.Fields),
});
}
public ActionResult Index(string option, string username)
{
_viewModel = new HeaderViewModel();
if (option != null)
{
switch (option.ToLower())
{
case "newsfeed":
{
CreateLayoutView("Trang cá nhân");
break;
}
case "about":
{
CreateLayoutView("Thông tin");
break;
}
case "friend":
{
CreateLayoutView("Bạn bè");
break;
}
default:
{
CreateLayoutView("Trang cá nhân");
break;
}
}
}
else
{
CreateLayoutView("Trang cá nhân");
}
if (username == null || username == "false")
{
username = _viewModel.User.UserName;
}
var user = _service.GetUserByUserName(username);
FieldHelper.CopyNotNullValue(HeaderViewModel, user);
Friend friend = _friendService.FindRelationship(User.Identity.GetUserId(), user.Id);
if (friend != null)
{
HeaderViewModel.CodeRelationshipId = friend.CodeRelationshipId;
HeaderViewModel.Id_User_Request = friend.Id_User;
}
return(View(_viewModel));
}
/// <summary>
/// Get an ExprType that's appropriate for a given field.
/// </summary>
/// <param name="fieldEntity"></param>
/// <returns></returns>
public static ExprType FromFieldEntity(IEntity fieldEntity)
{
DataType dataType = FieldHelper.ConvertToDataType(fieldEntity);
ExprType exprType = new ExprType(dataType);
DecimalField decimalField = fieldEntity.As <DecimalField>();
if (decimalField != null)
{
exprType.DecimalPlaces = decimalField.DecimalPlaces;
}
return(exprType);
}
public void TestReadValidIdInput(Enums.ResourceType resourceType)
{
string resourceName = resourceType.ToResourceName();
string fieldAlias = $"{resourceName}.{SystemTypeField.Id}";
string id = records.Data[$"{resourceType.ToPrivateEnum()}0"].Id.ToString();
ReadResponseData <XmlResource> result = FieldHelper.ReadResource(resourceType, id, new List <string> {
fieldAlias
});
Assert.That(result.Items[0].DictionaryValues[fieldAlias].ToString(), Is.EqualTo(id), $"{fieldAlias} does not match!");
}
public void TestSearchMultipleSearchConditionUsing1Field(Enums.ResourceType resourceType, List <string> fieldValues, string condition1, string condition2)
{
string resourceName = resourceType.ToResourceName();
string fieldAlias = customFields.Data[$"{resourceType}"].Field.ToAlias();
Assume.That(fieldAlias, Is.Not.Null.And.Not.Empty, "Cannot create a user field for " + resourceName);
Dictionary <string, string> parameters = FieldHelper.CreateOneFieldSearchInstance(records, cleaner, resourceType, fieldAlias, fieldValues, condition1, condition2);
//Read & verify the field's value
DateTimeValidator.VerifySearchDate(resourceType, parameters);
}
public bool UpdateProjectSubscription(UpdateProjectSubscriptionEvent updateSubscription)
{
var dbProject = GetExistingProjectSubscription(updateSubscription.SubscriptionUID.Value);
if (dbProject == null)
{
throw new Exception("Project Subscription not exists!");
}
if (string.IsNullOrEmpty(updateSubscription.SubscriptionType) && !updateSubscription.CustomerUID.HasValue &&
!updateSubscription.StartDate.HasValue && !updateSubscription.EndDate.HasValue)
{
throw new Exception("Update Project Subscription Request should have atleast one field to update");
}
if (string.IsNullOrEmpty(updateSubscription.SubscriptionType))
{
updateSubscription.SubscriptionType = _projectSubscriptionTypeCache
.FirstOrDefault(x => x.Value == dbProject.fk_ServiceTypeID).Key;
}
else if (_projectSubscriptionTypeCache.ContainsKey(updateSubscription.SubscriptionType))
{
dbProject.fk_ServiceTypeID = _projectSubscriptionTypeCache[updateSubscription.SubscriptionType];
}
else
{
throw new Exception("Invalid Project Subscription Type");
}
if (!FieldHelper.IsValidValuesFilled(updateSubscription, dbProject, logger))
{
logger.LogError("Second Parameter expects typeOf IDbTable");
}
dbProject.UpdateUTC = DateTime.UtcNow;
var kafkaMessage = new KafkaMessage()
{
Key = updateSubscription.SubscriptionUID.ToString(),
Message = new { UpdateProjectSubscriptionEvent = updateSubscription }
};
var actions = new List <Action>();
actions.Add(() => transaction.Upsert(dbProject));
actions.Add(() => topics.ToList().ForEach(topic =>
{
kafkaMessage.Topic = topic;
transaction.Publish(kafkaMessage);
}));
return(transaction.Execute(actions));
}
private RegisterUserFormFields GetFormFields(RegisterUserData data, FormSubmitContext formSubmitContext)
{
Assert.ArgumentNotNull(data, nameof(data));
Assert.ArgumentNotNull(formSubmitContext, nameof(formSubmitContext));
return(new RegisterUserFormFields
{
Email = FieldHelper.GetFieldValueByName("Email", formSubmitContext.Fields),
Password = FieldHelper.GetFieldValueByName("Password Confirmation", formSubmitContext.Fields),
FullName = FieldHelper.GetFieldValueByName("Full Name", formSubmitContext.Fields),
});
}
private PackageFormFields GetFormFields(UploadPackageData data, FormSubmitContext formSubmitContext)
{
Assert.ArgumentNotNull(data, nameof(data));
Assert.ArgumentNotNull(formSubmitContext, nameof(formSubmitContext));
return(new PackageFormFields
{
PackageName = FieldHelper.GetFieldById(data.PackageNameFieldId, formSubmitContext.Fields),
PackageIdentifier = FieldHelper.GetFieldById(data.PackageIdentifierFieldId, formSubmitContext.Fields),
File = FieldHelper.GetFieldById(data.FileFieldId, formSubmitContext.Fields)
});
}
public IEnumerable <TestMethod> BuildFrom(IMethodInfo testMethod, Test suite)
{
if (testMethod.MethodInfo.ReflectedType == null)
{
return(new List <TestMethod>());
}
var fields = FieldHelper.GetFields(testMethod.MethodInfo.ReflectedType);
return(fields[typeof(then)]
.Select(f => _builder.BuildTestMethod(testMethod, suite, new TestCaseParameters(new object[] { f.Name }))));
}
private void AttachValidators(StringValidatorAttribute validator, Object control)
{
FieldHelper.ApplyWebControlAttribute(control, "minlength", validator.MinSize.ToString(CultureInfo.InvariantCulture));
FieldHelper.ApplyWebControlAttribute(control, "maxlength", validator.MaxSize.ToString(CultureInfo.InvariantCulture));
if (validator.IsRequired)
{
FieldHelper.ApplyWebControlAttribute(control, "required", "required");
}
FieldHelper.ApplyWebControlAttribute(control, "data-error", "test message");
}
public new void AttachValidators(List <IValidatorAttribute> validators, object control)
{
base.AttachValidators(validators, control);
foreach (var validator in validators)
{
if (validator is TestValidatorAttribute)
{
FieldHelper.SetPropertyValue(control, "Text", "TEST");
}
}
}
public void TestReadInvalidInput(Enums.ResourceType resourceType, string fieldName, ReadInvalidInput invalidInput)
{
string resourceName = resourceType.ToResourceName();
string fieldAlias = $"{resourceName}.{SystemTypeField.Id}";
string id = records.Data[$"{resourceType.ToPrivateEnum()}0"].Id.ToString();
id = string.Format(FieldValueMapperInvalidRead.InvalidInputMapper[invalidInput], id);
ReadResponseData <XmlResource> result = FieldHelper.ReadResource(resourceType, id, new List <string> {
fieldAlias
});
Assert.That(result.Code, Is.EqualTo(Enums.PublicAPIResultCode.InvalidParameterValue), Enums.Message.WRONG_ERROR_CODE);
}
public void TestReadValidIdInput(Enums.ResourceType resourceType, Enums.ResourceType referenceResourceType, string fieldName)
{
string resourceName = resourceType.ToResourceName();
string fieldAlias = $"{resourceName}.{fieldName}";
string id = records.Data[$"{referenceResourceType.ToPrivateEnum()}0"].Id.ToString();
ReadResponseData <XmlResource> result = FieldHelper.ReadReferenceResource(resourceType, id, fieldAlias);
Assert.That(result, MustBe.ReadSuccess(1), string.Format(Enums.Message.READ_RESOURCE_FAILED, resourceName));
XmlResource referenceResource = result.Items[0].DictionaryValues[fieldAlias] as XmlResource;
Assert.That((referenceResource.DictionaryValues[referenceResourceType.ToString()] as XmlResource).DictionaryValues[$"{referenceResourceType.ToResourceName()}.P_Id"], Is.EqualTo(id), $"{fieldAlias} does not match!");
}
public void TestReadValidUserInput(Enums.ResourceType resourceType, string fieldName)
{
string resourceName = resourceType.ToResourceName();
string fieldAlias = $"{resourceName}.{fieldName}";
string id = records.Data[$"{resourceType.ToPrivateEnum()}0"].Id.ToString();
ReadResponseData <XmlResource> result = FieldHelper.ReadResource(resourceType, id, new List <string> {
fieldAlias
});
XmlResource user = (result.Items[0].DictionaryValues[fieldAlias] as XmlResource).DictionaryValues["User"] as XmlResource;
Assert.That(user.DictionaryValues["User.P_Id"].ToString(), Is.EqualTo(DefaultUser), $"{fieldAlias} does not match!");
}
public void TestSearchField(Enums.ResourceType resourceType, List <string> fieldValues, string condition)
{
string resourceName = resourceType.ToResourceName();
string fieldAlias = $"{resourceName}.{FieldHelper.AppDateField1}";
//Check registered application field
FieldHelper.CheckRegisteredField(readFields, resourceType, FieldHelper.AppDateField1);
Dictionary <string, string> parameters = FieldHelper.CreateSearchInstance(records, cleaner, resourceType, fieldAlias, fieldValues, condition);
//Read & verify the field's value
DateTimeValidator.VerifySingleSearchFieldDate(resourceType, parameters);
}
public ActionResult About(string username)
{
_viewModel = new AboutViewModel();
CreateLayoutView("Thông tin");
if (username == "false")
{
username = _viewModel.User.UserName;
}
var user = _service.GetUserByUserName(username);
FieldHelper.CopyNotNullValue(AboutViewModel, user);
return(PartialView("_About", AboutViewModel));
}
static void Prefix(StandardLevelDetailView __instance, IBeatmapLevel level, BeatmapDifficulty defaultDifficulty, BeatmapCharacteristicSO defaultBeatmapCharacteristic, PlayerData playerData)
{
List <BeatmapCharacteristicSO> toGenerate = new List <BeatmapCharacteristicSO>();
if (Config.Instance.ShowGenerated360)
{
toGenerate.Add(GameModeHelper.GetGenerated360GameMode());
}
if (Config.Instance.ShowGenerated90)
{
toGenerate.Add(GameModeHelper.GetGenerated90GameMode());
}
List <IDifficultyBeatmapSet> sets = new List <IDifficultyBeatmapSet>(level.beatmapLevelData.difficultyBeatmapSets);
// Generate each custom gamemode
foreach (BeatmapCharacteristicSO customGameMode in toGenerate)
{
if (level.beatmapLevelData.difficultyBeatmapSets.Any((e) => e.beatmapCharacteristic.serializedName == GameModeHelper.GENERATED_360DEGREE_MODE))
{
// Already added the generated gamemode
continue;
}
IDifficultyBeatmapSet basedOnGameMode = level.beatmapLevelData.difficultyBeatmapSets.FirstOrDefault((e) => e.beatmapCharacteristic.serializedName == Config.Instance.BasedOn);
if (basedOnGameMode == null)
{
// Level does not have a standard mode to base its 360 mode on
continue;
}
CustomDifficultyBeatmapSet customSet = new CustomDifficultyBeatmapSet(customGameMode);
CustomDifficultyBeatmap[] difficulties = basedOnGameMode.difficultyBeatmaps.Select((e) => new CustomDifficultyBeatmap(e.level, customSet, e.difficulty, e.difficultyRank, e.noteJumpMovementSpeed, e.noteJumpStartBeatOffset, e.beatmapData.GetCopy())).ToArray();
customSet.SetCustomDifficultyBeatmaps(difficulties);
sets.Add(customSet);
}
// Update difficultyBeatmapSets
if (level.beatmapLevelData is BeatmapLevelData data)
{
if (!FieldHelper.Set(data, "_difficultyBeatmapSets", sets.ToArray()))
{
Plugin.Log.Warn("Could not set new difficulty sets");
return;
}
}
else
{
Plugin.Log.Info("Unsupported beatmapLevelData: " + (level.beatmapLevelData?.GetType().FullName ?? "null"));
}
}
private void btnImportFC_Click(object sender, EventArgs e)
{
frmOpenFile frm = new frmOpenFile();
frm.AddFilter(new MyGxFilterFeatureClasses(), true);
if (frm.DoModalOpen() != DialogResult.OK)
{
return;
}
IGxDataset gxObject = frm.SelectedItems[0] as IGxDataset;
if (gxObject == null)
{
return;
}
DialogResult result = MessageBox.Show("导入字段时是否清空已有字段?", "询问", MessageBoxButtons.YesNoCancel,
MessageBoxIcon.Question);
if (result == DialogResult.Cancel)
{
return;
}
if (result == DialogResult.Yes)
{
_fieldTable.Rows.Clear();
}
IFeatureClass pClass = gxObject.Dataset as IFeatureClass;
for (int i = 0; i < pClass.Fields.FieldCount; i++)
{
IField pField = pClass.Fields.Field[i];
if (pField.Type == esriFieldType.esriFieldTypeGeometry || pField.Type == esriFieldType.esriFieldTypeOID)
{
continue;
}
string pFldName = pField.Name;
if (_fieldTable.Select("FieldName='" + pFldName + "'").Length > 0)
{
continue;
}
DataRow pRow = _fieldTable.NewRow();
pRow["FieldName"] = pField.Name;
pRow["AliasName"] = pField.AliasName;
pRow["AllowNull"] = pField.IsNullable;
pRow["FieldType"] = FieldHelper.ConvertToSimpleString(pField.Type);
//pRow["IsKey"] = pField.DefaultValue==null ? "": pField.DefaultValue;
pRow["FieldLength"] = pField.Length;
pRow["Precision"] = pField.Precision;
_fieldTable.Rows.Add(pRow);
}
}
public async System.Threading.Tasks.Task <PartialViewResult> Post(PostViewModel data)
{
Post newPost = new Post();
newPost.Post_Status = 0;
_viewModel = new PostViewModel();
FieldHelper.CopyNotNullValue(newPost, data);
newPost.CreatedDate = DateTime.Now;
if (data.Option == 0 && newPost.Id_Type == 8)
{
//post to fb toiec
var IdPost = await _fbService.PostingToGroupFB(newPost.Content);
newPost.Id_PostFB = IdPost.id;
}
_postService.Add(newPost);
_postService.Save();
// string url = MaHoaMD5.Encrypt(newPost.Id + "#" + newPost.UpdatedDate);
//Send notify
ApplicationUser userPost = _service.GetUserById(newPost.Id_User);
FieldHelper.CopyNotNullValue(PostViewModel, userPost);
FieldHelper.CopyNotNullValue(PostViewModel, newPost);
PostViewModel.TypeToString = _postTypeService.GetById(newPost.Id_Type).Name;
PostVoteDetail vote = _postVoteDetailService.getVoteByIdUser(newPost.Id_User, newPost.Id);
if (vote != null)
{
PostViewModel.Vote = vote.Vote;
}
//Send noti for all user register
var userIDList = getUserIDListBasedOnType(newPost.Id_Type);
foreach (var userID in userIDList)
{
var sendPostToUser = _service.GetUserById(userID);
if (sendPostToUser.Id_Messenger != userPost.Id_Messenger && sendPostToUser.Id_Messenger != null && _eventService.IsFreeTime(sendPostToUser.Email))
{
//Create json send............
FBPostNoti newNoti = new FBPostNoti();
newNoti.recipient.id = sendPostToUser.Id_Messenger;
newNoti.message.attachment.payload.text = "```\r\n" + "💬 Bạn có một câu hỏi: " + "\r\n" + '"' + newPost.Content + '"' + "\r\n```";
NotiButton button = new NotiButton();
button.payload = "REPLAY_" + newPost.Id;
newNoti.message.attachment.payload.buttons.Add(button);
//
ChatBotMessenger.sendRequest(JsonConvert.SerializeObject(newNoti));
}
}
return(PartialView("_Post", PostViewModel));
}
public void UpdateRow(IRow pRow)
{
pRow.Value[pRow.Fields.FindField("FieldName")] = _name;
pRow.Value[pRow.Fields.FindField("AliasName")] = _aliasName;
pRow.Value[pRow.Fields.FindField("FieldLength")] = _length;
pRow.Value[pRow.Fields.FindField("FieldPrecision")] = _precision;
pRow.Value[pRow.Fields.FindField("FieldType")] = FieldHelper.ConvertToSimpleString(_fieldType);
pRow.Value[pRow.Fields.FindField("AllowNull")] = _allowNull ? "True" : "False";
pRow.Value[pRow.Fields.FindField("IsKey")] = _isKey ? "True" : "False";
pRow.Value[pRow.Fields.FindField("FieldDomain")] = _domain;
pRow.Value[pRow.Fields.FindField("DefaultValue")] = _defaultValue;
pRow.Store();
_id = pRow.OID;
}
public void WinCounter()
{
if (FieldHelper.GetGameState(Field, Player) == GameStates.Gewonnen)
{
if (Player == Player1)
{
Player1.WinCounter++;
}
else
{
Player2.WinCounter++;
}
}
}
private void ResolveDependencies()
{
this._fieldHelper = AppContainer.Current.Resolve<FieldHelper>();
this._listHelper = AppContainer.Current.Resolve<ListHelper>();
this._contentTypeHelper = AppContainer.Current.Resolve<ContentTypeHelper>();
}
