public void AddPermission(TypeOfEntity typeOfEntity, Subdivision subdivision)
{
if (typeOfEntity == null || subdivision == null || PermissionExists(typeOfEntity, subdivision))
{
return;
}
EntitySubdivisionForUserPermission savedPermission;
var foundOriginalPermission = originalPermissionList.FirstOrDefault(x => x.TypeOfEntity == typeOfEntity && x.Subdivision == subdivision);
if (foundOriginalPermission == null)
{
savedPermission = new EntitySubdivisionForUserPermission()
{
Subdivision = subdivision,
TypeOfEntity = typeOfEntity,
User = user
};
ObservablePermissionsList.Add(savedPermission);
}
else
{
if (deletionPermissionList.Contains(foundOriginalPermission))
{
deletionPermissionList.Remove(foundOriginalPermission);
}
savedPermission = foundOriginalPermission;
ObservablePermissionsList.Add(savedPermission);
}
}
public static void ChoosenTypeOfAssociation(out TypeOfEntity ourTypeOfEntity)
{
int ourLocalChoice;
WriteLine("Выберите тип обьединения : ");
WriteLine("\t1. Студенческое ");
WriteLine("\t2. Преподавательское");
Write("\tВвод : ");
ourLocalChoice = MainActions.GetCorrectPositiveInt(1, 2);
switch (ourLocalChoice)
{
case 1:
{
ourTypeOfEntity = TypeOfEntity.Student;
}
break;
case 2:
{
ourTypeOfEntity = TypeOfEntity.Employee;
}
break;
default:
{
ourTypeOfEntity = TypeOfEntity.Student;
}
break;
}
}
public IList <EntitySubdivisionForUserPermission> GetAllSubdivisionForUserEntityPermissionForSomeEntities(IUnitOfWork uow, int userId, string[] entityNames)
{
EntitySubdivisionForUserPermission entitySubdivisionPermissionAlias = null;
TypeOfEntity typeOfEntityAlias = null;
return(uow.Session.QueryOver(() => entitySubdivisionPermissionAlias)
.Left.JoinAlias(() => entitySubdivisionPermissionAlias.TypeOfEntity, () => typeOfEntityAlias)
.Where(() => entitySubdivisionPermissionAlias.User.Id == userId)
.WhereRestrictionOn(() => typeOfEntityAlias.Type).IsIn(entityNames)
.List());
}
public IList <EntitySubdivisionForUserPermission> GetAllSubdivisionForUserEntityPermissionForOneEntity(IUnitOfWork uow, int userId, string entityName)
{
EntitySubdivisionForUserPermission entitySubdivisionPermissionAlias = null;
TypeOfEntity typeOfEntityAlias = null;
return(uow.Session.QueryOver(() => entitySubdivisionPermissionAlias)
.Left.JoinAlias(() => entitySubdivisionPermissionAlias.TypeOfEntity, () => typeOfEntityAlias)
.Where(() => entitySubdivisionPermissionAlias.User.Id == userId)
.Where(() => typeOfEntityAlias.Type == entityName)
.List());
}
/// <summary>
/// Список подразделений в которых произодится работа с указанными документами
/// </summary>
public IEnumerable <Subdivision> GetSubdivisionsForDocumentTypes(IUnitOfWork uow, Type[] documentTypes)
{
Subdivision subdivisionAlias = null;
TypeOfEntity typeOfEntityAlias = null;
return(uow.Session.QueryOver <Subdivision>(() => subdivisionAlias)
.Left.JoinAlias(() => subdivisionAlias.DocumentTypes, () => typeOfEntityAlias)
.WhereRestrictionOn(() => typeOfEntityAlias.Type).IsIn(documentTypes.Select(x => x.Name).ToArray())
.List()
.Distinct()
);
}
public GameObject Create(TypeOfEntity type)
{
switch (type)
{
case TypeOfEntity.Empty:
case TypeOfEntity.Player:
return(Instantiate((GameObject)Resources.Load("Entity/Player"), Vector3.zero, new Quaternion(0, 0, 0, 1)));
default:
return(null);
}
}
public EntitySubdivisionOnlyPermission GetSubdivisionEntityPermission(IUnitOfWork uow, string entityName, int subdisionId)
{
EntitySubdivisionOnlyPermission entitySubdivisionPermissionAlias = null;
Subdivision subdivisionAlias = null;
TypeOfEntity typeOfEntityAlias = null;
return(uow.Session.QueryOver(() => entitySubdivisionPermissionAlias)
.Left.JoinAlias(() => entitySubdivisionPermissionAlias.Subdivision, () => subdivisionAlias)
.Left.JoinAlias(() => entitySubdivisionPermissionAlias.TypeOfEntity, () => typeOfEntityAlias)
.Where(() => subdivisionAlias.Id == subdisionId)
.Where(() => typeOfEntityAlias.Type == entityName)
.SingleOrDefault());
}
public EntityUserPermission GetUserEntityPermission(IUnitOfWork uow, string entityName, int userId)
{
TypeOfEntity typeOfEntityAlias = null;
EntityUserPermission entityUserPermissionAlias = null;
UserBase userBaseAlias = null;
return(uow.Session.QueryOver <EntityUserPermission>(() => entityUserPermissionAlias)
.Left.JoinAlias(() => entityUserPermissionAlias.User, () => userBaseAlias)
.Left.JoinAlias(() => entityUserPermissionAlias.TypeOfEntity, () => typeOfEntityAlias)
.Where(() => userBaseAlias.Id == userId)
.Where(() => typeOfEntityAlias.Type == entityName)
.SingleOrDefault());
}
public void AddPermission(TypeOfEntity entityNode)
{
if (entityNode == null)
{
return;
}
ObservableTypeOfEntitiesList.Remove(entityNode);
UserPermissionNode savedPermission;
var foundOriginalPermission = PermissionListViewModel.PermissionsList.OfType <UserPermissionNode>().FirstOrDefault(x => x.TypeOfEntity == entityNode);
if (foundOriginalPermission == null)
{
savedPermission = new UserPermissionNode();
savedPermission.EntityUserOnlyPermission = new EntityUserPermission()
{
User = user,
TypeOfEntity = entityNode
};
savedPermission.EntityPermissionExtended = new List <EntityUserPermissionExtended>();
foreach (var item in PermissionListViewModel.PermissionExtensionStore.PermissionExtensions)
{
var node = new EntityUserPermissionExtended();
node.User = user;
node.TypeOfEntity = entityNode;
node.PermissionId = item.PermissionId;
savedPermission.EntityPermissionExtended.Add(node);
}
savedPermission.TypeOfEntity = entityNode;
PermissionListViewModel.PermissionsList.Add(savedPermission);
}
else
{
if (deletePermissionList.Contains(foundOriginalPermission))
{
deletePermissionList.Remove(foundOriginalPermission);
}
savedPermission = foundOriginalPermission;
PermissionListViewModel.PermissionsList.Add(savedPermission);
}
}
public ScientificAssociation(TypeOfEntity typeOfEntity)
{
this.typeOfEntity = typeOfEntity;
associationID = membersArray.Count;
switch (typeOfEntity)
{
case TypeOfEntity.Employee:
{
typeOfAssociation = "Преподавательское";
}
break;
case TypeOfEntity.Student:
{
typeOfAssociation = "Студенческое";
}
break;
}
}
public GameObject Build(TypeOfEntity type, TypeOfWeapon wType = TypeOfWeapon.Fist)
{
entity = EntityFactory.instance.Create(type);
switch (type)
{
default:
case TypeOfEntity.Empty:
return(entity);
case TypeOfEntity.Player:
entity.name = "Player";
entity.layer = Layers.Player;
Player player = entity.AddComponent <Player>();
GameObject weapon = WeaponBuilder.instance.Build(wType);
weapon.transform.parent = entity.transform;
player.SetWeaponManager(weapon.GetComponent <WeaponManager>());
return(entity);
}
}
public void AddPermission(TypeOfEntity entityNode)
{
if (entityNode == null)
{
return;
}
ObservableTypeOfEntitiesList.Remove(entityNode);
SubdivisionPermissionNode savedPermission;
var foundOriginalPermission = originalPermissionList.FirstOrDefault(x => x.TypeOfEntity == entityNode);
if (foundOriginalPermission == null)
{
savedPermission = new SubdivisionPermissionNode();
savedPermission.EntitySubdivisionOnlyPermission = new EntitySubdivisionOnlyPermission {
Subdivision = subdivision,
TypeOfEntity = entityNode
};
savedPermission.EntityPermissionExtended = new List <EntitySubdivisionPermissionExtended>();
foreach (var item in ExtensionStore.PermissionExtensions)
{
var node = new EntitySubdivisionPermissionExtended();
node.Subdivision = subdivision;
node.TypeOfEntity = entityNode;
node.PermissionId = item.PermissionId;
savedPermission.EntityPermissionExtended.Add(node);
}
savedPermission.TypeOfEntity = entityNode;
PermissionListViewModel.PermissionsList.Add(savedPermission);
}
else
{
savedPermission = foundOriginalPermission;
PermissionListViewModel.PermissionsList.Add(savedPermission);
}
}
public bool Validate(Type entityType, int userId, IPermissionExtension permissionExtension)
{
if (!permissionExtension.IsValidType(entityType))
{
return(false);
}
using (var uow = UnitOfWorkFactory.CreateWithoutRoot())
{
User user = uow.GetById <User>(userId);
Employee employee = EmployeeRepository.GetEmployeesForUser(uow, userId).FirstOrDefault();
TypeOfEntity typeOfEntity = uow.Session.QueryOver <TypeOfEntity>()
.Where(x => x.Type == entityType.Name)
.Take(1).List().FirstOrDefault();
if (user == null)
{
return(false);
}
if (user.IsAdmin)
{
return(true);
}
if (typeOfEntity == null)
{
return(false);
}
if (employee == null || employee.Subdivision == null)
{
return(false);
}
Subdivision subdivisionAlias = null;
var userPermission = uow.Session.QueryOver <EntityPermissionExtended>()
.Left.JoinAlias(x => x.Subdivision, () => subdivisionAlias)
.Where(x => x.User.Id == user.Id)
.And(Restrictions.On(() => subdivisionAlias.Id).IsNull)
.And(x => x.PermissionId == permissionExtension.PermissionId)
.And(x => x.TypeOfEntity.Id == typeOfEntity.Id)
.Take(1).List().FirstOrDefault();
if (userPermission != null)
{
if (userPermission.IsPermissionAvailable == null)
{
throw new NullReferenceException(nameof(userPermission));
}
else
{
return(userPermission.IsPermissionAvailable.Value);
}
}
Subdivision subdivision = null;
do
{
if (subdivisionAlias == null)
{
subdivisionAlias = employee.Subdivision;
}
else
{
subdivisionAlias = subdivisionAlias.ParentSubdivision;
}
User userAlias = null;
var subdivisionPermission = uow.Session.QueryOver <EntityPermissionExtended>()
.Left.JoinAlias(x => x.User, () => userAlias)
.Where(x => x.Subdivision.Id == subdivisionAlias.Id)
.And(Restrictions.On(() => userAlias.Id).IsNull)
.And(x => x.PermissionId == permissionExtension.PermissionId)
.And(x => x.TypeOfEntity.Id == typeOfEntity.Id)
.Take(1).List().FirstOrDefault();
if (subdivisionPermission == null)
{
continue;
}
if (subdivisionPermission.IsPermissionAvailable == null)
{
throw new NullReferenceException(nameof(subdivisionPermission));
}
return(subdivisionPermission.IsPermissionAvailable.Value);
}while(subdivisionAlias.ParentSubdivision != null);
}
return(false);
}
public bool PermissionExists(TypeOfEntity type, Subdivision subdivision)
{
return(ObservablePermissionsList.Any(x => x.TypeOfEntity == type && x.Subdivision == subdivision));
}
public MainChar(TypeOfEntity typeOfEntity, int posX, int posY) : base(typeOfEntity, posX, posY)
{
this.typeOfEntity = TypeOfEntity.MainChar;
}
/* Methods */
//Constructor
public Entity(TypeOfEntity typeOfEntity, int posX, int posY)
{
this.typeOfEntity = typeOfEntity;
this.posX = posX;
this.posY = posY;
}
public MovingEntity(TypeOfEntity typeOfEntity, int posX, int posY) : base(typeOfEntity, posX, posY)
{
}
public Car(TypeOfEntity typeOfEntity, int posX, int posY) : base(typeOfEntity, posX, posY)
{
this.typeOfEntity = TypeOfEntity.Car;
}
public EntityValidtionContext(IEntity entity)
{
TypeOfEntity = entity.GetType();
Properties = TypeOfEntity.GetProperties().ToList();
}
// Here i use enums.
public static void NoExistMassege(bool flag, TypeOfEntity typeOfEntity, AmountOfEntities amountOfEntities)
{
if (flag == false)
{
switch (typeOfEntity)
{
case TypeOfEntity.Student:
{
switch (amountOfEntities)
{
case AmountOfEntities.One:
{
WriteLine("( Such studen doesn't exist )");
}
break;
case AmountOfEntities.Several:
{
WriteLine("( There's no one student )");
}
break;
}
}
break;
case TypeOfEntity.Employee:
{
switch (amountOfEntities)
{
case AmountOfEntities.One:
{
WriteLine("( Such employee doesn't exist )");
}
break;
case AmountOfEntities.Several:
{
WriteLine("( There's no one employee )");
}
break;
}
}
break;
case TypeOfEntity.Book:
{
switch (amountOfEntities)
{
case AmountOfEntities.One:
{
WriteLine("( Such book doesn't exist )");
}
break;
case AmountOfEntities.Several:
{
WriteLine("( There's no books )");
}
break;
}
}
break;
case TypeOfEntity.Association:
{
switch (amountOfEntities)
{
case AmountOfEntities.One:
{
WriteLine("( Such association doesn't exist ) ");
}
break;
case AmountOfEntities.Several:
{
WriteLine("( There's no associations )");
}
break;
}
}
break;
default:
{
throw new FormatException(String.Format($"The {typeOfEntity} type of TypeOfEntity is not supported."));
}
break;
}
}
}
