/// <summary>
/// Initializes a new instance of the <see cref="Core.Models.Definitions.UnitDefinition"/> class.
/// </summary>
/// <param name="unitType">Unit type.</param>
/// <param name="actions">Actions which are possible.</param>
/// <param name="attack">Attack damage.</param>
/// <param name="defense">Defense of the entity.</param>
/// <param name="health">Health of the entity.</param>
/// <param name="moves">Move range.</param>
/// <param name="attackRange">Attack range.</param>
/// <param name="population">Population cost.</param>
/// <param name="scrapcost">Scrap cost.</param>
/// <param name="energycost">Energy cost.</param>
/// <param name="plutoniumcost">Plutonium cost.</param>
/// <param name="techcost">Tech cost.</param>
public UnitDefinition(
EntityType unitType,
string[] actions,
int attack,
int defense,
int health,
int moves,
int attackRange,
int population,
int scrapcost,
int energycost,
int plutoniumcost,
int techcost)
: base((int)unitType)
{
Actions = actions;
Attack = attack;
Defense = defense;
Health = health;
Moves = moves;
AttackRange = attackRange;
Population = population;
Scrapecost = scrapcost;
Energycost = energycost;
Plutoniumcost = plutoniumcost;
Techcost = techcost;
}
/// <summary>
/// Initializes a new instance of the DefaultThumbnailViewModel class.
/// </summary>
/// <param name="thumbnailID">Thumbnail Guid</param>
/// <param name="entity">Type of the entity</param>
/// <param name="altText">Alt text for IMG tag</param>
/// <param name="contentType">Content Type of the content. In case of community, it will be generic which will not be used.</param>
public DefaultThumbnailViewModel(Guid? thumbnailID, EntityType entity, string altText, ContentTypes contentType)
{
this.ThumbnailID = thumbnailID;
this.Entity = entity;
this.AltText = HttpContext.Current.Server.HtmlEncode(altText);
this.ContentType = contentType;
}
private static ModelElement CreateModelElementForEFObjectType(EFObject obj, Partition partition)
{
ModelElement modelElement = null;
var t = obj.GetType();
if (t == typeof(ConceptualEntityModel))
{
modelElement = new EntityDesignerViewModel(partition);
}
else if (t == typeof(ConceptualEntityType))
{
modelElement = new EntityType(partition);
}
else if (t == typeof(ConceptualProperty))
{
modelElement = new ScalarProperty(partition);
}
else if (t == typeof(ComplexConceptualProperty))
{
modelElement = new ComplexProperty(partition);
}
else if (t == typeof(Association))
{
modelElement = new ViewModel.Association(partition);
}
else if (t == typeof(EntityTypeBaseType))
{
modelElement = new Inheritance(partition);
}
else if (t == typeof(NavigationProperty))
{
modelElement = new ViewModel.NavigationProperty(partition);
}
return modelElement;
}
protected void Page_Load(object sender, EventArgs e)
{
_manageTagPopup.Options.IsPopup = true;
entityType = StringToEntityType(Request["view"]);
_switcherEntityType.SortItemsHeader = CRMCommonResource.Show + ":";
_forContacts.SortLabel = CRMSettingResource.BothPersonAndCompany;
_forContacts.SortUrl = "settings.aspx?type=tag";
_forContacts.IsSelected = entityType == EntityType.Contact;
_forDeals.SortLabel = CRMCommonResource.DealModuleName;
_forDeals.SortUrl = String.Format("settings.aspx?type=tag&view={0}", EntityType.Opportunity.ToString().ToLower());
_forDeals.IsSelected = entityType == EntityType.Opportunity;
_forCases.SortLabel = CRMCommonResource.CasesModuleName;
_forCases.SortUrl = String.Format("settings.aspx?type=tag&view={0}", EntityType.Case.ToString().ToLower());
_forCases.IsSelected = entityType == EntityType.Case;
RegisterClientScriptHelper.DataTagSettingsView(Page, entityType);
RegisterScript();
}
public void Get_generation_property_returns_generation_property_from_foreign_key_tree()
{
var model = new Model();
var leftType = new EntityType("Left", model);
var leftId = leftType.AddProperty("Id", typeof(int), true);
var leftKey = leftType.AddKey(leftId);
var rightType = new EntityType("Right", model);
var rightId1 = rightType.AddProperty("Id1", typeof(int), true);
var rightId2 = rightType.AddProperty("Id2", typeof(int), true);
var rightKey = rightType.AddKey(new[] { rightId1, rightId2 });
var middleType = new EntityType("Middle", model);
var middleProperty1 = middleType.AddProperty("FK1", typeof(int), true);
var middleProperty2 = middleType.AddProperty("FK2", typeof(int), true);
var middleKey1 = middleType.AddKey(middleProperty1);
var middleFK1 = middleType.AddForeignKey(middleProperty1, leftKey, leftType);
var middleFK2 = middleType.AddForeignKey(new[] { middleProperty2, middleProperty1 }, rightKey, rightType);
var endType = new EntityType("End", model);
var endProperty = endType.AddProperty("FK", typeof(int), true);
var endFK = endType.AddForeignKey(endProperty, middleKey1, middleType);
rightId2.RequiresValueGenerator = true;
Assert.Equal(rightId2, endProperty.GetGenerationProperty());
}
private string buildNoticeLink(NotificationType noticeType, int entityId, EntityType entityType)
{
string result = "";
switch (entityType)
{
case EntityType.Project:
switch (noticeType)
{
case NotificationType.BidSubmitted:
result = string.Format("/Project/{0}/Bid/Received", entityId);
break;
case NotificationType.InvitationRequest:
result = string.Format("/Project/{0}/Invitation/Requests", entityId);
break;
case NotificationType.InvitationResponse:
case NotificationType.InvitationToBid:
case NotificationType.ProjectChange:
result = string.Format("/Project/Details/{0}", entityId);
break;
}
break;
case EntityType.Company:
switch (noticeType)
{
case NotificationType.ConnectionAccepted:
case NotificationType.RequestToConnect:
result = string.Format("/Company/Profile/{0}", entityId);
break;
}
break;
}
return result;
}
/// <summary>
/// Adds a new row to the EntitySet with the specified entity type.
/// </summary>
/// <param name="entityType">Entity type for the new row.</param>
/// <returns>Instance of <see cref="EntitySetDataRow"/> for the newly added row.</returns>
public EntitySetDataRow AddNewRowOfType(EntityType entityType)
{
ExceptionUtilities.CheckArgumentNotNull(entityType, "entityType");
this.CheckEntityTypeBelongsToEntitySet(entityType);
return this.AddNewRowOfTypeInternal(entityType);
}
public AnimatedSprite(Texture2D texture, EntityType entityType, IList<AnimationSequence> animations, AnimationActions initialAnimationAction,
Rectangle worldPosition, Vector2 speed = new Vector2(), Vector2 direction = new Vector2(), bool isCollidable = false, int collisionOffset = 0)
: base(texture, entityType, worldPosition, speed: speed, direction: direction, isCollidable: isCollidable, collisionOffset: collisionOffset)
{
Animations = animations;
CurrentAnimation = Animations.First(a => a.AnimationAction == initialAnimationAction);
}
protected List<int> SearchByTags(EntityType entityType, int[] exceptIDs, IEnumerable<String> tags)
{
if (tags == null || !tags.Any())
throw new ArgumentException();
var tagIDs = new List<int>();
foreach (var tag in tags)
tagIDs.Add(DbManager.ExecuteScalar<int>(Query("crm_tag")
.Select("id")
.Where(Exp.Eq("entity_type", (int)entityType ) & Exp.Eq("title", tag))));
var sqlQuery = new SqlQuery("crm_entity_tag")
.Select("entity_id")
.Select("count(*) as count")
.GroupBy("entity_id")
.Having(Exp.Eq("count", tags.Count()));
if (exceptIDs != null && exceptIDs.Length > 0)
sqlQuery.Where(Exp.In("entity_id", exceptIDs) & Exp.Eq("entity_type", (int)entityType));
else
sqlQuery.Where(Exp.Eq("entity_type", (int)entityType));
sqlQuery.Where(Exp.In("tag_id", tagIDs));
return DbManager.ExecuteList(sqlQuery).ConvertAll(row => Convert.ToInt32(row[0]));
}
/// <summary>Creates a new, empty Entity object of the type specified</summary>
/// <param name="entityTypeToCreate">The entity type to create.</param>
/// <returns>A new, empty Entity object.</returns>
public static IEntity2 Create(EntityType entityTypeToCreate)
{
IEntityFactory2 factoryToUse = null;
switch(entityTypeToCreate)
{
case DirectSports.BL.EntityType.ProductEntity:
factoryToUse = new ProductEntityFactory();
break;
case DirectSports.BL.EntityType.ProductSectionEntity:
factoryToUse = new ProductSectionEntityFactory();
break;
case DirectSports.BL.EntityType.ProductVariationEntity:
factoryToUse = new ProductVariationEntityFactory();
break;
case DirectSports.BL.EntityType.RoleEntity:
factoryToUse = new RoleEntityFactory();
break;
case DirectSports.BL.EntityType.SpecialOfferEntity:
factoryToUse = new SpecialOfferEntityFactory();
break;
case DirectSports.BL.EntityType.UserEntity:
factoryToUse = new UserEntityFactory();
break;
case DirectSports.BL.EntityType.UserRoleLinkEntity:
factoryToUse = new UserRoleLinkEntityFactory();
break;
}
return factoryToUse.Create();
}
public static EntityType EntityType()
{
var entityType = new EntityType(typeof(NullablePoco));
entityType.AddProperty("NullInt", typeof(int?));
entityType.AddProperty("NullDouble", typeof(double?));
return entityType;
}
public UserControlledSprite(Texture2D texture, EntityType entityType, IList<AnimationSequence> animations, AnimationActions initialAnimationAction,
Rectangle worldPosition, int moveSpeed, bool isCollidable = false, int collisionOffset = 0)
: base(texture, entityType, animations, initialAnimationAction, worldPosition, isCollidable: isCollidable,
collisionOffset: collisionOffset)
{
MaxMoveSpeed = moveSpeed;
}
public Book(string inputTitle, string inputAuthors, int inputYear,
string inputPublisher, string inputPublisherAddr, EntityType inputEntityType, DateTime inputEntryDate)
: base(inputTitle, inputAuthors, inputYear, inputEntityType, inputEntryDate)
{
Publisher = inputPublisher;
PublisherAddr = inputPublisherAddr;
}
/*
* Builds the dynamic Insert query for all the entities
*/
public int GetEntity(int scanID, EntityType entity, ref ArrayList entData)
{
try
{
using (SqlCeCommand command = Connection.CreateCommand())
{
command.CommandText = SelectConditionalQueryString(entity, "where ScanID = ?");
command.Parameters.Add(new SqlCeParameter("ScanID",
SqlDbType.Int, 4)).Value = scanID;
using (SqlCeDataReader reader = command.ExecuteReader())
{
while (reader.Read())
{
entData.Add(DataReaderToObject(reader, entity));
}
}
}
}
catch (Exception)
{
}
return 1;
}
public Dictionary<int, List<String>> GetEntitiesTags(EntityType entityType)
{
var result = new Dictionary<int, List<String>>();
var sqlQuery =
new SqlQuery("crm_entity_tag")
.Select("entity_id", "title")
.LeftOuterJoin("crm_tag", Exp.EqColumns("id", "tag_id"))
.Where(Exp.Eq("crm_tag.entity_type", (int)entityType) & Exp.Eq("crm_tag.tenant_id", TenantID))
.OrderBy("entity_id", true)
.OrderBy("title", true);
using (var db = GetDb())
{
db.ExecuteList(sqlQuery).ForEach(row =>
{
var entityID = Convert.ToInt32(row[0]);
var tagTitle = Convert.ToString(row[1]);
if (!result.ContainsKey(entityID))
result.Add(entityID, new List<String>
{
tagTitle
});
else
result[entityID].Add(tagTitle);
});
}
return result;
}
public bool Create(EntityType entityType)
{
if (IsServer() == false)
{
Debug.LogError("Client cannot spawn enemies, please use ServerCreateRequest if it is from server request");
return false;
}
Vector3 position = EntitySpawnPoint.transform.position;
Quaternion rotation = EntitySpawnPoint.transform.rotation;
GameObject instantiateObject = null;
float randX = Random.Range(-3, 3);
float randZ = Random.Range(-3, 3);
Vector3 newPosition = new Vector3(position.x + randX, position.y, position.z + randZ);
instantiateObject = InstantiateEntityType(entityType, newPosition, rotation);
if (instantiateObject != null)
{
instantiateObject.transform.parent = transform;
instantiateObject.name = instantiateObject.name + "Ins" + iInstantiateCounter;
iInstantiateCounter++;
SendRPC("InstantiateEntity", RPCMode.Others, (int) entityType, instantiateObject.name, newPosition, rotation);
return true;
}
return false;
}
private GameObject InstantiateEntityType(EntityType entityType, Vector3 position, Quaternion rotation)
{
GameObject instantiateObject = null;
switch (entityType)
{
case EntityType.Worker:
instantiateObject = (GameObject)Instantiate(WorkerPrefab, position, rotation);
break;
case EntityType.WarriorGreen:
instantiateObject = (GameObject)Instantiate(WarriorGreenPrefab, position, rotation);
break;
case EntityType.Tower:
towerSelector.StartCreating();
instantiateObject = null;
break;
case EntityType.WarriorYellow:
instantiateObject = (GameObject)Instantiate(WarriorYellowPrefab, position, rotation);
break;
case EntityType.WarriorRed:
instantiateObject = (GameObject)Instantiate(WarriorRedPrefab, position, rotation);
break;
default:
break;
}
return instantiateObject;
}
/// <summary>General factory entrance method which will return an EntityFields object with the format generated by the factory specified</summary>
/// <param name="relatedEntityType">The type of entity the fields are for</param>
/// <returns>The IEntityFields2 instance requested</returns>
public static IEntityFields2 CreateEntityFieldsObject(EntityType relatedEntityType)
{
IEntityFields2 fieldsToReturn=null;
switch(relatedEntityType)
{
case DirectSports.BL.EntityType.ProductEntity:
fieldsToReturn = CreateProductEntityFields();
break;
case DirectSports.BL.EntityType.ProductSectionEntity:
fieldsToReturn = CreateProductSectionEntityFields();
break;
case DirectSports.BL.EntityType.RoleEntity:
fieldsToReturn = CreateRoleEntityFields();
break;
case DirectSports.BL.EntityType.SpecialOfferEntity:
fieldsToReturn = CreateSpecialOfferEntityFields();
break;
case DirectSports.BL.EntityType.UserEntity:
fieldsToReturn = CreateUserEntityFields();
break;
case DirectSports.BL.EntityType.UserRoleLinkEntity:
fieldsToReturn = CreateUserRoleLinkEntityFields();
break;
}
return fieldsToReturn;
}
/// <summary>
/// Handles the SaveClick event of the mdEdit control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param>
protected void mdEdit_SaveClick( object sender, EventArgs e )
{
var rockContext = new RockContext();
EntityTypeService entityTypeService = new EntityTypeService( rockContext );
EntityType entityType = entityTypeService.Get( int.Parse( hfEntityTypeId.Value ) );
if ( entityType == null )
{
entityType = new EntityType();
entityType.IsEntity = true;
entityType.IsSecured = true;
entityTypeService.Add( entityType );
}
entityType.Name = tbName.Text;
entityType.FriendlyName = tbFriendlyName.Text;
entityType.IsCommon = cbCommon.Checked;
rockContext.SaveChanges();
EntityTypeCache.Flush( entityType.Id );
hfEntityTypeId.Value = string.Empty;
HideDialog();
BindGrid();
}
public Article(string inputTitle, string inputAuthors, int inputYear,
string inputJournal, int inputVolume, EntityType inputEntityType, DateTime inputEntryDate)
: base(inputTitle, inputAuthors, inputYear, inputEntityType, inputEntryDate)
{
Journal = inputJournal;
Volume = inputVolume;
}
public Thesis(string inputTitle, string inputAuthor, int inputYear,
ThesisType inputThesisEntityType, string inputSchool, EntityType inputEntityType, DateTime inputEntryDate)
: base(inputTitle, inputAuthor, inputYear, inputEntityType, inputEntryDate)
{
School = inputSchool;
ThesisEntityType = inputThesisEntityType;
}
public AAnimate(EntityType type, string texture_path, int width, int height, float posx, float posy, float speed)
: base(type, texture_path, posx, posy, speed)
{
Width = width;
Height = height;
sprite = new SpriteSheet(Defaults.MOUVEMENT_PHASE_MIDDLE, Defaults.MOUVEMENT_DIRECTION_DOWN, Width, Height);
}
public AAnimate(SpriteSheet sp, EntityType type, string texture_path, float posx, float posy, float speed)
: base(type, texture_path, posx, posy, speed)
{
sprite = sp;
Width = sp.getWidth();
Height = sp.getHeight();
}
private static void AppendDescriptionUsingContext(DbContext context, StringBuilder builder, EntityType type, ActionType aType, object entity)
{
string additionalInfo = string.Empty;
string identity = string.Empty;
var enrty = context.Entry(entity);
var prop =
enrty.Entity.GetType()
.GetProperties()
.FirstOrDefault(c => c.GetCustomAttributes(typeof(KeyAttribute), true).FirstOrDefault() != null);
var name = enrty.Entity.GetType().GetProperties().FirstOrDefault(c => c.Name.Contains("Name"));
identity = CreateIdentityString(entity, prop, identity, name);
if (aType == ActionType.Updating)
{
additionalInfo = string.Format("Были изменены следующие поля: {0}",
string.Join(",", enrty.CurrentValues.PropertyNames));
}
if (aType != ActionType.Import || aType != ActionType.Export)
{
builder.Append(string.Format("Сущность \"{0}\" {1} была {2}.{3}", type.GetEntityTypeName(), identity,
aType.GetActionTypeName(), additionalInfo));
}
}
/// <summary>
/// Gets the specified <see cref="Rock.Model.EntityType"/> by the object type. If a match is not found, it can optionally create a new <see cref="Rock.Model.EntityType"/> for the object.
/// </summary>
/// <param name="type">The <see cref="System.Type"/> to search for.</param>
/// <param name="createIfNotFound">A <see cref="System.Boolean"/> value that indicates if a new <see cref="Rock.Model.EntityType"/> should be created if a match is not found. This value
/// will be <c>true</c> if a new <see cref="Rock.Model.EntityType"/> should be created if there is not a match; otherwise <c>false</c>/</param>
/// <param name="personAlias">A <see cref="Rock.Model.PersonAlias"/> representing the alias of the <see cref="Rock.Model.Person"/> who is searching for and possibly creating a new EntityType. This value can be
/// null if the logged in person is not known (i.e. an anonymous user).</param>
/// <returns>A <see cref="Rock.Model.EntityType"/> matching the provided type. If a match is not found and createIfNotFound is false this value will be null.</returns>
public EntityType Get( Type type, bool createIfNotFound, PersonAlias personAlias )
{
var entityType = Get( type.FullName );
if ( entityType != null )
{
return entityType;
}
if ( createIfNotFound )
{
// Create a new context so type can be saved independing of current context
using ( var rockContext = new RockContext() )
{
var EntityTypeService = new EntityTypeService( rockContext );
entityType = new EntityType();
entityType.Name = type.FullName;
entityType.FriendlyName = type.Name.SplitCase();
entityType.AssemblyName = type.AssemblyQualifiedName;
EntityTypeService.Add( entityType );
rockContext.SaveChanges();
}
// Read type using current context
return this.Get( entityType.Id );
}
return null;
}
public static EntityType EntityType()
{
var entityType = new EntityType(typeof(IntKeysPoco));
entityType.AddProperty("PartitionID", typeof(int)).SetColumnName("PartitionKey");
entityType.AddProperty("RowID", typeof(int)).SetColumnName("RowKey");
return entityType;
}
public void StartImport(EntityType entityType, String CSVFileURI, String importSettingsJSON)
{
ImportFromCSV.Start(entityType, CSVFileURI, importSettingsJSON);
var action = GetMessageAction(entityType);
MessageService.Send(HttpContext.Current.Request, action);
}
private EntityType RemoveEntityType(EntityType entityType)
{
var referencingForeignKey = entityType.GetDeclaredReferencingForeignKeys().FirstOrDefault();
if (referencingForeignKey != null)
{
throw new InvalidOperationException(
CoreStrings.EntityTypeInUseByForeignKey(
entityType.DisplayName(),
"{" + string.Join(", ", referencingForeignKey.Properties.Select(p => "'" + p.Name + "'")) + "}",
referencingForeignKey.DeclaringEntityType.DisplayName()));
}
var derivedEntityType = entityType.GetDirectlyDerivedTypes().FirstOrDefault();
if (derivedEntityType != null)
{
throw new InvalidOperationException(
CoreStrings.EntityTypeInUseByDerived(
entityType.DisplayName(),
derivedEntityType.DisplayName()));
}
var removed = _entityTypes.Remove(entityType.Name);
entityType.Builder = null;
return entityType;
}
public override bool Resolve(ICollection<IEntity> resultingSet, string name, EntityType typesToConsider)
{
bool found = false;
foreach (InternalModule m in InternalModules())
{
if (string.IsNullOrEmpty(m.Namespace))
{
if (m.Resolve(resultingSet, name, typesToConsider))
found = true;
continue;
}
if (!HasNamespacePrefix(m, name))
continue;
if (m.Namespace.Length == name.Length)
{
resultingSet.Add(m.ModuleMembersNamespace);
found = true;
continue;
}
if (m.Namespace[name.Length] == '.')
{
resultingSet.Add(new PartialModuleNamespace(name, m));
found = true;
continue;
}
}
return found;
}
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
public virtual Expression BindNavigation(INavigation navigation, bool clientEval)
{
if (!EntityType.IsAssignableFrom(navigation.DeclaringEntityType) &&
!navigation.DeclaringEntityType.IsAssignableFrom(EntityType))
{
throw new InvalidOperationException(
$"Called EntityProjectionExpression.GetNavigation() with incorrect INavigation. EntityType:{EntityType.DisplayName()}, Navigation:{navigation.Name}");
}
if (!_navigationExpressionsCache.TryGetValue(navigation, out var expression))
{
if (navigation.IsCollection())
{
expression = new ObjectArrayProjectionExpression(navigation, AccessExpression);
}
else
{
expression = new EntityProjectionExpression(
navigation.GetTargetType(),
new ObjectAccessExpression(navigation, AccessExpression));
}
_navigationExpressionsCache[navigation] = expression;
}
if (!clientEval &&
expression.Name.Length == 0)
{
// Non-persisted navigation can't be translated
return(null);
}
return((Expression)expression);
}
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
public virtual Expression BindProperty(IProperty property, bool clientEval)
{
if (!EntityType.IsAssignableFrom(property.DeclaringEntityType) &&
!property.DeclaringEntityType.IsAssignableFrom(EntityType))
{
throw new InvalidOperationException(
$"Called EntityProjectionExpression.GetProperty() with incorrect IProperty. EntityType:{EntityType.DisplayName()}, Property:{property.Name}");
}
if (!_propertyExpressionsCache.TryGetValue(property, out var expression))
{
expression = new KeyAccessExpression(property, AccessExpression);
_propertyExpressionsCache[property] = expression;
}
if (!clientEval &&
expression.Name.Length == 0)
{
// Non-persisted property can't be translated
return(null);
}
return((Expression)expression);
}
/// <summary>
/// Gets the .NET type from the AQD.Model.EntityType specified.
/// </summary>
/// <param name="typeOfEntity">The type of entity.</param>
/// <returns>.NET type fo the entity or null if not found</returns>
public static Type GetTypeFromEntityTypeEnum(EntityType typeOfEntity)
{
var ef = EntityFactoryFactory.GetFactory(typeOfEntity);
return(ef != null?ef.Create().GetType() : null);
}
public AttackData(EntityType victim, EntityType attacker, bool entityKilled)
{
this.victim = victim;
this.attacker = attacker;
this.entityKilled = entityKilled;
}
public bool Resolve(ICollection <IEntity> resultingSet, string name, EntityType typesToConsider)
{
return(BaseType.Resolve(resultingSet, name, typesToConsider));
}
public static RelationalEntityTypeAnnotations MySQL(this EntityType entityType)
{
return((RelationalEntityTypeAnnotations)MySQL((IEntityType)entityType));
}
public override bool Resolve(ICollection <IEntity> resultingSet, string name, EntityType flags)
{
return(false);
}
private static Expression <Func <T, IEnumerable <TChild> > > GetRootEntityToChildCollectionSelector <T, TChild>(EntityType cSpaceType)
where T : class
where TChild : class
{
var parameter = Expression.Parameter(typeof(T), "t");
var memberExpression = Expression.Property(parameter, cSpaceType.NavigationProperties.First(p => p.ToEndMember.GetEntityType().Name == typeof(TChild).Name).Name);
var lambdaExpression = Expression.Lambda <Func <T, IEnumerable <TChild> > >(memberExpression, parameter);
return(lambdaExpression);
}
override public bool Resolve(ICollection <IEntity> resultingSet, string name, EntityType typesToConsider)
{
bool found = base.Resolve(resultingSet, name, typesToConsider);
foreach (TypeReference baseType in _node.BaseTypes)
{
if (TypeSystemServices.GetType(baseType).Resolve(resultingSet, name, typesToConsider))
{
found = true;
}
}
if (!found)
{
// also look in System.Object
if (BaseType.Resolve(resultingSet, name, typesToConsider))
{
found = true;
}
}
return(found);
}
public override bool Resolve(System.Collections.Generic.ICollection <IEntity> resultingSet, string name, EntityType typesToConsider)
{
return(Namespaces.ResolveCoalescingNamespaces(this, Delegates, name, typesToConsider, resultingSet));
}
public void RegularUserMakesAChangeIsLogged()
{
var toDelete = new List <long>();
try
{
var userAccount = Entity.Create <UserAccount>();
userAccount.Name = "Test user " + Guid.NewGuid().ToString();
userAccount.Save();
toDelete.Add(userAccount.Id);
new AccessRuleFactory()
.AddAllowByQuery(
userAccount.As <Subject>(),
UserResource.UserResource_Type.As <SecurableEntity>(),
new EntityRef[] { new EntityRef("core:create") },
TestQueries.EntitiesWithName("Creatable").ToReport());
new AccessRuleFactory()
.AddAllowByQuery(
userAccount.As <Subject>(),
UserResource.UserResource_Type.As <SecurableEntity>(),
new EntityRef[] { new EntityRef("core:modify") },
TestQueries.EntitiesWithName("bob").ToReport());
var entityType = new EntityType {
Name = "Creatable"
};
entityType.Inherits.Add(UserResource.UserResource_Type);
entityType.Save();
toDelete.Add(entityType.Id);
var policy = new RecordChangeAuditPolicy()
{
Name = "TEST ResourceAuditEventHandlerTests RegularUserMakesAChangeIsLogged", TriggeredOnType = entityType, TriggerEnabled = true
};
policy.UpdatedFieldsToTriggerOn.Add(Resource.Description_Field.Cast <Field>());
policy.Save();
toDelete.Add(policy.Id);
var log = RunAndLog(() =>
{
using (new SetUser(userAccount))
{
var entity = Entity.Create(entityType);
entity.SetField(Resource.Name_Field.As <Field>(), "bob");
entity.SetField(Resource.Description_Field.As <Field>(), "first");
entity.Save();
toDelete.Add(entity.Id);
entity = entity.AsWritable();
entity.SetField(Resource.Description_Field.As <Field>(), "second");
entity.Save();
}
});
Assert.That(log.Count, Is.EqualTo(2));
Assert.That(log[0].Description, Is.EqualTo("[Description] set to 'first'"));
Assert.That(log[1].Description, Is.EqualTo("[Description] changed from 'first' -> 'second'"));
}
finally
{
Entity.Delete(toDelete);
}
}
public static Entity Create(this EntityType entityType, World world)
{
Entity entity = null;
switch (entityType)
{
case EntityType.None:
return(null);
case EntityType.Chicken:
entity = new Chicken(world);
break;
case EntityType.Cow:
entity = new Cow(world);
break;
case EntityType.Pig:
entity = new Pig(world);
break;
case EntityType.Sheep:
entity = new Sheep(world);
break;
case EntityType.Wolf:
entity = new Wolf(world);
break;
case EntityType.Villager:
entity = new Villager(world);
break;
case EntityType.MushroomCow:
entity = new Mooshroom(world);
break;
case EntityType.Squid:
entity = new Squid(world);
break;
case EntityType.Rabbit:
entity = new Rabbit(world);
break;
case EntityType.Bat:
entity = new Bat(world);
break;
case EntityType.IronGolem:
entity = new VillagerGolem(world);
break;
case EntityType.SnowGolem:
entity = new Snowman(world);
break;
case EntityType.Ocelot:
entity = new Ocelot(world);
break;
case EntityType.Zombie:
entity = new Zombie(world);
break;
case EntityType.Creeper:
entity = new Creeper(world);
break;
case EntityType.Skeleton:
entity = new Skeleton(world);
break;
case EntityType.Spider:
entity = new Spider(world);
break;
case EntityType.ZombiePigman:
entity = new ZombiePigman(world);
break;
case EntityType.Slime:
entity = new Slime(world);
break;
case EntityType.Endermite:
entity = new Endermite(world);
break;
case EntityType.Enderman:
entity = new Enderman(world);
break;
case EntityType.Silverfish:
entity = new Silverfish(world);
break;
case EntityType.CaveSpider:
entity = new CaveSpider(world);
break;
case EntityType.Ghast:
entity = new Ghast(world);
break;
case EntityType.MagmaCube:
entity = new MagmaCube(world);
break;
case EntityType.Blaze:
entity = new Blaze(world);
break;
case EntityType.ZombieVillager:
entity = new ZombieVillager(world);
break;
case EntityType.Witch:
entity = new Witch(world);
break;
case EntityType.Stray:
entity = new Stray(world);
break;
case EntityType.Husk:
entity = new Husk(world);
break;
case EntityType.WitherSkeleton:
entity = new WitherSkeleton(world);
break;
case EntityType.Guardian:
entity = new Guardian(world);
break;
case EntityType.ElderGuardian:
entity = new ElderGuardian(world);
break;
case EntityType.Horse:
entity = new Horse(world);
break;
case EntityType.ZombieHorse:
entity = new ZombieHorse(world);
break;
case EntityType.PolarBear:
entity = new PolarBear(world);
break;
case EntityType.Shulker:
entity = new Shulker(world);
break;
case EntityType.EnderDragon:
entity = new EnderDragon(world);
break;
case EntityType.SkeletonHorse:
entity = new SkeletonHorse(world);
break;
case EntityType.Wither:
entity = new Wither(world);
break;
case EntityType.Evoker:
entity = new EvocationIllager(world);
break;
case EntityType.Vindicator:
entity = new VindicationIllager(world);
break;
case EntityType.Vex:
entity = new Vex(world);
break;
case EntityType.FallingBlock:
entity = new EntityFallingBlock(world);
break;
case EntityType.ArmorStand:
entity = new EntityArmorStand(world, null);
break;
case EntityType.Arrow:
entity = new ArrowEntity(world, null);
break;
case EntityType.Item:
entity = new ItemEntity(world);
break;
case EntityType.Mooshroom:
entity = new Mooshroom(world);
break;
case EntityType.Snowball:
entity = new SnowballEntity(world, null);
break;
case EntityType.ThrownEgg:
entity = new EggEntity(world, null);
break;
case EntityType.Donkey:
entity = new Donkey(world);
break;
case EntityType.Llama:
entity = new Llama(world);
break;
case EntityType.Mule:
entity = new Mule(world);
break;
case EntityType.Fox:
entity = new Fox(world);
break;
case EntityType.Parrot:
entity = new Parrot(world);
break;
case EntityType.Phantom:
entity = new Phantom(world);
break;
case EntityType.Bee:
entity = new Bee(world);
break;
case EntityType.LlamaSpit:
entity = new LlamaSpit(world);
break;
case EntityType.Cat:
entity = new Cat(world);
break;
case EntityType.SmallFireball:
entity = new SmallFireball(world);
break;
case EntityType.Fireball:
entity = new Fireball(world);
break;
case EntityType.Dolphin:
entity = new Dolphin(world);
break;
case EntityType.Cod:
entity = new Cod(world);
break;
case EntityType.PufferFish:
entity = new PufferFish(world);
break;
case EntityType.Salmon:
entity = new Salmon(world);
break;
case EntityType.TropicalFish:
entity = new TropicalFish(world);
break;
case EntityType.FireworkRocket:
entity = new FireworkRocket(world, null);
break;
//case EntityType.Human:
//entity = new PlayerMob("test", world, );
// break;
default:
return(null);
}
return(entity);
}
/// <summary> /// This API supports the Entity Framework Core infrastructure and is not intended to be used /// directly from your code. This API may change or be removed in future releases. /// </summary> public virtual bool Apply(InternalEntityTypeBuilder entityTypeBuilder, EntityType oldBaseType) => Apply(entityTypeBuilder) != null;
/// <summary>
/// Adds a message to the AuditLog
/// </summary>
/// <param name="merchelloContext">
/// The merchello context.
/// </param>
/// <param name="key">
/// The key.
/// </param>
/// <param name="entityType">
/// The <see cref="EntityType"/>
/// </param>
/// <param name="message">
/// The message.
/// </param>
private static void UpdateAuditLog(IMerchelloContext merchelloContext, Guid key, EntityType entityType, string message)
{
if (string.IsNullOrEmpty(message) || key == Guid.Empty)
{
return;
}
if (!MerchelloConfiguration.Current.Section.EnableLogging)
{
return;
}
try
{
merchelloContext.Services.AuditLogService.CreateAuditLogWithKey(key, entityType, message);
}
catch (Exception ex)
{
LogHelper.Error(typeof(SalesHistoryAuditingExtensions), string.Format("Failed to log {0} for entityType {1} with key {2}", message, entityType, key), ex);
}
}
public void SetEntityType(EntityType type)
{
_entityType = type;
}
private IReadOnlyList <Property> GetCompatiblePrimaryKeyProperties(EntityType dependentEntityType, EntityType principalEntityType, IReadOnlyList <Property> propertiesToReference)
{
var dependentPkProperties = dependentEntityType.FindPrimaryKey()?.Properties;
if (dependentPkProperties != null &&
ForeignKey.AreCompatible(
propertiesToReference,
dependentPkProperties,
principalEntityType,
dependentEntityType,
shouldThrow: false))
{
return(dependentPkProperties);
}
return(null);
}
/// <summary>
/// The log.
/// </summary>
/// <param name="key">
/// The key.
/// </param>
/// <param name="entityType">
/// The entity type.
/// </param>
/// <param name="message">
/// The message.
/// </param>
internal static void UpdateAuditLog(Guid key, EntityType entityType, string message)
{
UpdateAuditLog(MerchelloContext.Current, key, entityType, message);
}
/// <summary>
/// This API supports the Entity Framework Core infrastructure and is not intended to be used
/// directly from your code. This API may change or be removed in future releases.
/// </summary>
public override object this[string propertyName]
{
get { return(GetValueInternal(EntityType.GetProperty(propertyName))); }
set { SetValueInternal(EntityType.GetProperty(propertyName), value); }
}
/// <summary>
/// This API supports the Entity Framework Core infrastructure and is not intended to be used
/// directly from your code. This API may change or be removed in future releases.
/// </summary>
public override object this[IProperty property]
{
get { return(GetValueInternal(EntityType.CheckPropertyBelongsToType(property))); }
set { SetValueInternal(EntityType.CheckPropertyBelongsToType(property), value); }
}
public void AddEntity(DbObjectKey key, EntityType type)
{
_entityLookup.Add(key, type);
_reverseEntityLookup.Add(type, key);
}
/// <summary>
/// Gets the member of the specified type with the specified name, assuming there is only one.
/// </summary>
private IEntity GetMember(IType type, string name, EntityType entityType)
{
return(NameResolutionService.ResolveMember(type, name, entityType));
}
/// <summary>
/// Gets the CLR instance type for the specified entity type.
/// </summary>
/// <param name="entity">The entity type to get the instance type for.</param>
/// <param name="canReflectOnInstanceType">true if reflection over the instance type is allowed; otherwise false.</param>
/// <returns>The CLR instance type to use.</returns>
protected override Type GetEntityInstanceType(EntityType entity, out bool canReflectOnInstanceType)
{
canReflectOnInstanceType = false;
return(typeof(DSPResource));
}
public EntitySet GetEntitySet(RelationshipEndMember end)
{
EntityType type = RelationshipEndTypeLookup[end];
return(EntityTypeToSet[type]);
}
/// <summary>
/// Add the stored Number to the entities' memory
/// </summary>
public MemoryTask(EntityType type)
{
_type = type;
}
public DamageNumberTask(EntityType type, bool spellDmg = false)
{
Type = type;
SpellDmg = spellDmg;
}
/// <summary>
/// Process the given action with the memory of entities
/// </summary>
public MemoryTask(EntityType type, Action <IPlayable, IList <int> > action)
{
_type = type;
_action = action;
}
/// <summary>
/// Copies the memory of the given entity to the stack.
/// </summary>
/// <param name="type"></param>
public MemoryToNumbersTask(EntityType type)
{
_type = type;
}
public void RelNameChangeDoesNotBreakExistingPolicy()
{
var toDelete = new List <long>();
try
{
var parentType = new EntityType {
Name = "dummy parent type"
};
parentType.Save();
toDelete.Add(parentType.Id);
var childType = new EntityType {
Name = "dummy child type"
};
childType.Save();
toDelete.Add(childType.Id);
var rel = new Relationship {
Name = "test rel", FromType = parentType, ToType = childType, Cardinality_Enum = CardinalityEnum_Enumeration.OneToOne
};
rel.Save();
toDelete.Add(rel.Id);
var policy = new RecordChangeAuditPolicy()
{
Name = "TEST ResourceAuditEventHandlerTests CascadeDeleteOfRelated", TriggeredOnType = parentType, TriggerEnabled = true
};
policy.UpdatedRelationshipsToTriggerOn.Add(rel);
policy.Save();
toDelete.Add(policy.Id);
rel = rel.AsWritable <Relationship>();
rel.Name = "renamed rel";
rel.Save();
var child = Entity.Create(childType);
child.SetField(Resource.Name_Field, "child");
child.Save();
toDelete.Add(child.Id);
var parent = Entity.Create(parentType);
parent.Save();
toDelete.Add(parent.Id);
var log = RunAndLog(() =>
{
parent = parent.AsWritable();
parent.GetRelationships(rel).Add(child);
parent.Save();
});
Assert.That(log.Count, Is.EqualTo(1));
var logEntry = log[0].As <RecordChangeLogEntry>();
Assert.That(logEntry.Description, Is.EqualTo("[renamed rel] set to 'child'"));
}
finally
{
Entity.Delete(toDelete);
}
}
public virtual bool Resolve(ICollection <IEntity> resultingSet, string name, EntityType typesToConsider)
{
return(My <NameResolutionService> .Instance.Resolve(name, GetMembers(), typesToConsider, resultingSet));
}
void TestRelationship(Func <EntityType, EntityType, Relationship> createRelFn, Action <RecordChangeAuditPolicy, EntityType, EntityType> setPolicyAction, Action <Resource, Resource, Relationship> updateAction, string expected)
{
var toDelete = new List <long>();
try
{
var rType1 = new EntityType()
{
Name = "rType1"
};
rType1.Inherits.Add(Resource.Resource_Type);
rType1.Save();
toDelete.Add(rType1.Id);
var rType2 = new EntityType()
{
Name = "rType2"
};
rType2.Inherits.Add(Resource.Resource_Type);
rType2.Save();
toDelete.Add(rType2.Id);
var rel = createRelFn(rType1, rType2);
rel.Save();
toDelete.Add(rel.Id);
var policy = new RecordChangeAuditPolicy()
{
Name = "TEST ResourceAuditEventHandlerTests ForwardLookup", TriggerEnabled = true
};
policy.UpdatedRelationshipsToTriggerOn.Add(rel);
setPolicyAction(policy, rType1, rType2);
policy.Save();
toDelete.Add(policy.Id);
var r1 = Entity.Create(rType1).As <Resource>();
r1.Name = "r1";
r1.Save();
var r2 = Entity.Create(rType2).As <Resource>();
r2.Name = "r2";
r2.Save();
var log = RunAndLog(() =>
{
updateAction(r1, r2, rel);
});
Assert.That(log.Count, Is.EqualTo(1));
var logEntry = log[0].As <RecordChangeLogEntry>();
Assert.That(logEntry, Is.Not.Null);
Assert.That(logEntry.Description, Is.StringContaining(expected));
}
finally
{
Entity.Delete(toDelete);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="SimpleConcreteGestureInputPlayable"/> class.
/// </summary>
/// <param name="mst">The MST.</param>
/// <param name="mask">The mask.</param>
/// <param name="et">The et.</param>
public SimpleConcreteGestureInputPlayable(GestureType gestureType, Action<GestureSample> mst = null, InputMask mask = InputMask.GSYSTEM, EntityType et = Input.EntityType.TOOLS)
{
this.GestureType = gestureType;
this.GestureFired += mst;
this.EntityType = et;
this.mask = mask;
}
