public static ShortPosition GetSingleShort(Guid uid)
{
var filter = new PositionFilter();
filter.UIDs.Add(uid);
var operationResult = ClientManager.RubezhService.GetPositionList(filter);
return Common.ThrowErrorIfExists(operationResult).FirstOrDefault();
}
private IQueryable <PositionDAO> OrFilter(IQueryable <PositionDAO> query, PositionFilter filter)
{
if (filter.OrFilter == null || filter.OrFilter.Count == 0)
{
return(query);
}
IQueryable <PositionDAO> initQuery = query.Where(q => false);
foreach (PositionFilter PositionFilter in filter.OrFilter)
{
IQueryable <PositionDAO> queryable = query;
if (PositionFilter.Id != null && PositionFilter.Id.HasValue)
{
queryable = queryable.Where(q => q.Id, PositionFilter.Id);
}
if (PositionFilter.Code != null && PositionFilter.Code.HasValue)
{
queryable = queryable.Where(q => q.Code, PositionFilter.Code);
}
if (PositionFilter.Name != null && PositionFilter.Name.HasValue)
{
queryable = queryable.Where(q => q.Name, PositionFilter.Name);
}
if (PositionFilter.StatusId != null && PositionFilter.StatusId.HasValue)
{
queryable = queryable.Where(q => q.StatusId, PositionFilter.StatusId);
}
initQuery = initQuery.Union(queryable);
}
return(initQuery);
}
public async Task <ActionResult <bool> > BulkDelete([FromBody] List <long> Ids)
{
if (UnAuthorization)
{
return(Forbid());
}
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
PositionFilter PositionFilter = new PositionFilter();
PositionFilter = await PositionService.ToFilter(PositionFilter);
PositionFilter.Id = new IdFilter {
In = Ids
};
PositionFilter.Selects = PositionSelect.Id;
PositionFilter.Skip = 0;
PositionFilter.Take = int.MaxValue;
List <Position> Positions = await PositionService.List(PositionFilter);
Positions = await PositionService.BulkDelete(Positions);
if (Positions.Any(x => !x.IsValidated))
{
return(BadRequest(Positions.Where(x => !x.IsValidated)));
}
return(true);
}
public async Task <int> Count(PositionFilter filter)
{
IQueryable <PositionDAO> Positions = DataContext.Position.AsNoTracking();
Positions = DynamicFilter(Positions, filter);
return(await Positions.CountAsync());
}
void Start()
{
meshScale = GetMeshScale();
skinnedRenderer = FaceMeshGameObject.GetComponent <SkinnedMeshRenderer>();
#if WINDOWS_UWP
xFilter = new PositionFilter(SigmaA, SigmaM, DecayRate);
yFilter = new PositionFilter(SigmaA, SigmaM, DecayRate);
zFilter = new PositionFilter(SigmaA, SigmaM, DecayRate);
#else
BuildMesh();
skinnedRenderer.sharedMesh = skinnedMesh;
#endif
cubes = new List <GameObject>();
for (int i = 0; i < NumberOfLandmarks; i++)
{
GameObject cube = GameObject.CreatePrimitive(PrimitiveType.Cube);
cube.transform.localScale = new Vector3(0.005f, 0.005f, 0.005f);
cubes.Add(cube);
}
landmarkPositions = new Vector3[NumberOfLandmarks];
HideDebug();
}
public async Task <List <Store_PositionDTO> > SingleListPosition([FromBody] Store_PositionFilterDTO Store_PositionFilterDTO)
{
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
PositionFilter PositionFilter = new PositionFilter();
PositionFilter.Skip = 0;
PositionFilter.Take = int.MaxValue;
PositionFilter.OrderBy = PositionOrder.Id;
PositionFilter.OrderType = OrderType.ASC;
PositionFilter.Selects = PositionSelect.ALL;
PositionFilter.Id = Store_PositionFilterDTO.Id;
PositionFilter.Code = Store_PositionFilterDTO.Code;
PositionFilter.Name = Store_PositionFilterDTO.Name;
List <Position> Positions = await PositionService.List(PositionFilter);
List <Store_PositionDTO> Store_PositionDTOs = Positions
.Select(x => new Store_PositionDTO(x)).ToList();
return(Store_PositionDTOs);
}
public void TestReset()
{
PositionFilter filter = new PositionFilter(new TestTokenStream(TEST_TOKEN));
AssertTokenStreamContents(filter, TEST_TOKEN, TEST_TOKEN_POSITION_INCREMENTS);
filter.Reset();
// Make sure that the reset filter provides correct position increments
AssertTokenStreamContents(filter, TEST_TOKEN, TEST_TOKEN_POSITION_INCREMENTS);
}
public async Task <PagedResult <PositionDto> > GetPositionsAsync(PositionFilter positionFilter)
{
var positionsPagedResult = await positionRepository.GetPositionsAsync(positionFilter);
var positionsDtoPagedResult = new PagedResult <PositionDto>();
Mapper.Map(positionsPagedResult, positionsDtoPagedResult);
return(positionsDtoPagedResult);
}
public HRFilter()
{
EmployeeFilter = new EmployeeFilter();
DepartmentFilter = new DepartmentFilter();
PositionFilter = new PositionFilter();
AdditionalColumnTypeFilter = new AdditionalColumnTypeFilter();
AccessTemplateFilter = new AccessTemplateFilter();
PassCardTemplateFilter = new PassCardTemplateFilter();
CardFilter = new CardFilter();
}
private Expression <Func <Position, bool> > GetPositionExpression(PositionFilter filter)
{
Expression <Func <Position, bool> > expression = null;
if (filter.Id > 0)
{
expression = x => x.Id == filter.Id;
}
return(expression);
}
public IEnumerable <Virus> VirusFromPosition(PositionFilter filter)
{
foreach (var v in crowd)
{
if (filter(v.VirusPosition))
{
yield return(v);
}
}
}
public bool Paste()
{
var filter = new PositionFilter { OrganisationUIDs = new List<Guid> { Position.OrganisationUID }};
var getPositionsResult = PositionHelper.Get(filter);
var positions = getPositionsResult;
Position.Name = CopyHelper.CopyName(Position.Name, positions.Select(x => x.Name));
return Save(true);
}
public ActionResult GetListGridJsonPagination(string filterStr, Pagination pagination, string sidx = " F_EnCode ", string sord = "desc")
{
if (string.IsNullOrEmpty(sidx))
{
sidx = " F_EnCode ";
}
PagerInfo pager = GetPageInfo(pagination);
List <AdvSearchEntity> advSearchList = new List <AdvSearchEntity>();
List <Mst_PositionInfo> lista;
if (string.IsNullOrEmpty(filterStr))
{
lista = baseBLL.FindWithPager(GetKeywordCondition("", filterStr), pager, sidx, sord.ToLower() == "desc");
}
else
{
PositionFilter filter = JsonAppHelper.ToObject <PositionFilter>(filterStr);
if (!string.IsNullOrEmpty(filter.F_EnCode))
{
advSearchList.Add(new AdvSearchEntity
{
F_condition = "And",
F_fvalue = filter.F_EnCode,
F_searchFiled = "F_EnCode",
F_type = "2"
});
}
if (!string.IsNullOrEmpty(filter.F_FullName))
{
advSearchList.Add(new AdvSearchEntity
{
F_condition = "And",
F_fvalue = filter.F_FullName,
F_searchFiled = "F_FullName",
F_type = "2"
});
}
if (!string.IsNullOrEmpty(filter.F_EnabledMark))
{
advSearchList.Add(new AdvSearchEntity
{
F_condition = "And",
F_fvalue = filter.F_EnabledMark,
F_searchFiled = "F_EnabledMark",
F_type = "0"
});
}
lista = BLLFactory <Mst_Position> .Instance.FindWithPager(GetAdvCondition(advSearchList), pager, sidx, sord.ToLower().Equals("desc"));
}
return(GetPagerContent <Mst_PositionInfo>(lista, pager));
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public void testFirstTokenPositionIncrement() throws Exception
public virtual void testFirstTokenPositionIncrement()
{
TokenStream ts = new MockTokenizer(new StringReader("a abc"), MockTokenizer.WHITESPACE, false);
ts = new PositionFilter(ts); // All but first token will get 0 position increment
EdgeNGramTokenFilter filter = new EdgeNGramTokenFilter(TEST_VERSION_CURRENT, ts, EdgeNGramTokenFilter.Side.FRONT, 2, 3);
// The first token "a" will not be output, since it's smaller than the mingram size of 2.
// The second token on input to EdgeNGramTokenFilter will have position increment of 0,
// which should be increased to 1, since this is the first output token in the stream.
assertTokenStreamContents(filter, new string[] { "ab", "abc" }, new int[] { 2, 2 }, new int[] { 5, 5 }, new int[] { 1, 0 });
}
public async Task <List <Position> > List(PositionFilter filter)
{
if (filter == null)
{
return(new List <Position>());
}
IQueryable <PositionDAO> PositionDAOs = DataContext.Position.AsNoTracking();
PositionDAOs = DynamicFilter(PositionDAOs, filter);
PositionDAOs = DynamicOrder(PositionDAOs, filter);
List <Position> Positions = await DynamicSelect(PositionDAOs, filter);
return(Positions);
}
public async Task <PositionFilter> ToFilter(PositionFilter filter)
{
if (filter.OrFilter == null)
{
filter.OrFilter = new List <PositionFilter>();
}
if (CurrentContext.Filters == null || CurrentContext.Filters.Count == 0)
{
return(filter);
}
foreach (var currentFilter in CurrentContext.Filters)
{
PositionFilter subFilter = new PositionFilter();
filter.OrFilter.Add(subFilter);
List <FilterPermissionDefinition> FilterPermissionDefinitions = currentFilter.Value;
foreach (FilterPermissionDefinition FilterPermissionDefinition in FilterPermissionDefinitions)
{
if (FilterPermissionDefinition.Name == nameof(subFilter.Id))
{
subFilter.Id = FilterBuilder.Merge(subFilter.Id, FilterPermissionDefinition.IdFilter);
}
if (FilterPermissionDefinition.Name == nameof(subFilter.Code))
{
subFilter.Code = FilterBuilder.Merge(subFilter.Code, FilterPermissionDefinition.StringFilter);
}
if (FilterPermissionDefinition.Name == nameof(subFilter.Name))
{
subFilter.Name = FilterBuilder.Merge(subFilter.Name, FilterPermissionDefinition.StringFilter);
}
if (FilterPermissionDefinition.Name == nameof(subFilter.StatusId))
{
subFilter.StatusId = FilterBuilder.Merge(subFilter.StatusId, FilterPermissionDefinition.IdFilter);
}
if (FilterPermissionDefinition.Name == nameof(CurrentContext.UserId) && FilterPermissionDefinition.IdFilter != null)
{
if (FilterPermissionDefinition.IdFilter.Equal.HasValue && FilterPermissionDefinition.IdFilter.Equal.Value == CurrentUserEnum.IS.Id)
{
}
if (FilterPermissionDefinition.IdFilter.Equal.HasValue && FilterPermissionDefinition.IdFilter.Equal.Value == CurrentUserEnum.ISNT.Id)
{
}
}
}
}
return(filter);
}
public void It_Should_Return_An_Element_At_Position_0()
{
// Arrange
LiquidCollection liquidCollection = new LiquidCollection {
LiquidString.Create("a string"),
LiquidNumeric.Create(123),
LiquidNumeric.Create(456m),
new LiquidBoolean(false)
};
var filter = new PositionFilter(LiquidNumeric.Create(0));
// Act
var result = filter.Apply(new TemplateContext(), liquidCollection).SuccessValue <LiquidString>();
// Assert
Assert.That(result, Is.EqualTo(liquidCollection[0]));
}
public async Task <PagedResult <Position> > GetPositionsAsync(PositionFilter filter)
{
filter = filter ?? new PositionFilter();
var result = unitOfWork.Query(GetPositionExpression(filter), filter.PropertiesToInclude);
List <Position> list = await result.OrderBy(filter.OrderBy)
.Skip((filter.Page - 1) * filter.Skip).Take(filter.Take)
.ToListAsync();
var pagedResult = new PagedResult <Position>
{
Data = list,
PageInfo = await GetPageInfo(x => x.Id, filter, GetPositionExpression(filter))
};
return(pagedResult);
}
private PositionFilter ConvertFilterDTOToFilterEntity(Position_PositionFilterDTO Position_PositionFilterDTO)
{
PositionFilter PositionFilter = new PositionFilter();
PositionFilter.Selects = PositionSelect.ALL;
PositionFilter.Skip = Position_PositionFilterDTO.Skip;
PositionFilter.Take = Position_PositionFilterDTO.Take;
PositionFilter.OrderBy = Position_PositionFilterDTO.OrderBy;
PositionFilter.OrderType = Position_PositionFilterDTO.OrderType;
PositionFilter.Id = Position_PositionFilterDTO.Id;
PositionFilter.Code = Position_PositionFilterDTO.Code;
PositionFilter.Name = Position_PositionFilterDTO.Name;
PositionFilter.StatusId = Position_PositionFilterDTO.StatusId;
PositionFilter.CreatedAt = Position_PositionFilterDTO.CreatedAt;
PositionFilter.UpdatedAt = Position_PositionFilterDTO.UpdatedAt;
return(PositionFilter);
}
public async Task <ActionResult <int> > Count([FromBody] Position_PositionFilterDTO Position_PositionFilterDTO)
{
if (UnAuthorization)
{
return(Forbid());
}
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
PositionFilter PositionFilter = ConvertFilterDTOToFilterEntity(Position_PositionFilterDTO);
PositionFilter = await PositionService.ToFilter(PositionFilter);
int count = await PositionService.Count(PositionFilter);
return(count);
}
public void It_Should_Return_An_Element_At_Position_0()
{
// Arrange
IList<IExpressionConstant> objlist = new List<IExpressionConstant>
{
new StringValue("a string"),
NumericValue.Create(123),
NumericValue.Create(456m),
new BooleanValue(false)
};
ArrayValue arrayValue = new ArrayValue(objlist);
var filter = new PositionFilter(NumericValue.Create(0));
// Act
var result = filter.Apply(new TemplateContext(), arrayValue).SuccessValue<StringValue>();
// Assert
Assert.That(result, Is.EqualTo(objlist[0]));
}
public HRViewModel(SKDTabItems skdTabItems)
{
SKDTabItems = skdTabItems;
EditFilterCommand = new RelayCommand(OnEditFilter, CanEditFilter);
ChangeIsDeletedCommand = new RelayCommand(OnChangeIsDeleted, CanChangeIsDeleted);
EmployeesViewModel = new EmployeesViewModel();
DepartmentsViewModel = new DepartmentsViewModel();
PositionsViewModel = new PositionsViewModel();
AdditionalColumnTypesViewModel = new AdditionalColumnTypesViewModel();
CardsViewModel = new CardsViewModel();
AccessTemplatesViewModel = new AccessTemplatesViewModel();
PassCardTemplatesViewModel = new PassCardTemplatesViewModel();
OrganisationsViewModel = new OrganisationsViewModel();
DepartmentFilter = new DepartmentFilter();
PositionFilter = new PositionFilter();
CardFilter = new CardFilter();
if (CanSelectEmployees)
IsEmployeesSelected = true;
else if (CanSelectDepartments)
IsDepartmentsSelected = true;
else if (CanSelectPositions)
IsPositionsSelected = true;
else if (CanSelectAdditionalColumns)
IsAdditionalColumnTypesSelected = true;
else if (CanSelectCards)
IsCardsSelected = true;
else if (CanSelectAccessTemplates)
IsAccessTemplatesSelected = true;
else if (CanSelectPassCardTemplates)
IsPassCardTemplatesSelected = true;
else if (CanSelectOrganisations)
IsOrganisationsSelected = true;
PersonTypes = new ObservableCollection<PersonType>();
if (ClientManager.CurrentUser.HasPermission(PermissionType.Oper_SKD_Employees_View))
PersonTypes.Add(PersonType.Employee);
if (ClientManager.CurrentUser.HasPermission(PermissionType.Oper_SKD_Guests_View))
PersonTypes.Add(PersonType.Guest);
_selectedPersonType = PersonTypes.FirstOrDefault();
var user = ClientManager.CurrentUser;
Filter = new HRFilter() { User = user };
Filter.EmployeeFilter.User = user;
}
public async Task <bool> ValidateId(Position Position)
{
PositionFilter PositionFilter = new PositionFilter
{
Skip = 0,
Take = 10,
Id = new IdFilter {
Equal = Position.Id
},
Selects = PositionSelect.Id
};
int count = await UOW.PositionRepository.Count(PositionFilter);
if (count == 0)
{
Position.AddError(nameof(PositionValidator), nameof(Position.Id), ErrorCode.IdNotExisted);
}
return(count == 1);
}
public ActionResult Index(PositionFilter filter, int?page)
{
if (filter != null)
{
filter.UserID = WebSecurity.CurrentUserId;
}
ViewBag.Difficulties = new SelectList(Enum.GetValues(typeof(DifficultyEnum)).Cast <DifficultyEnum>().ToList());
ViewBag.Orders = new SelectList(Enum.GetValues(typeof(OrderByEnum)).Cast <OrderByEnum>().ToList());
ViewBag.Categories = new SelectList(Enum.GetValues(typeof(CategoryEnum)).Cast <CategoryEnum>().ToList());
ViewBag.Bools = new SelectList(Enum.GetValues(typeof(BoolEnum)).Cast <BoolEnum>().ToList());
int pageSize = 5;
int pageNumber = (page ?? 1);
return(View(new IndexViewModel
{
Filter = filter,
Positions = PositionDataViewModel.MapToPositionDataViewModels(
PositionService.FilterPositions(filter, positionRepository.Positions), WebSecurity.CurrentUserId)
.ToPagedList(pageNumber, pageSize)
}));
}
public async Task <List <AppUser_PositionDTO> > FilterListPosition([FromBody] AppUser_PositionFilterDTO AppUser_PositionFilterDTO)
{
PositionFilter PositionFilter = new PositionFilter();
PositionFilter.Skip = 0;
PositionFilter.Take = 99999;
PositionFilter.OrderBy = PositionOrder.Id;
PositionFilter.OrderType = OrderType.ASC;
PositionFilter.Selects = PositionSelect.ALL;
PositionFilter.Id = AppUser_PositionFilterDTO.Id;
PositionFilter.Code = AppUser_PositionFilterDTO.Code;
PositionFilter.Name = AppUser_PositionFilterDTO.Name;
PositionFilter.StatusId = AppUser_PositionFilterDTO.StatusId;
List <Position> Positions = await PositionService.List(PositionFilter);
List <AppUser_PositionDTO> AppUser_PositionDTOs = Positions
.Select(x => new AppUser_PositionDTO(x)).ToList();
return(AppUser_PositionDTOs);
}
protected override DataSet CreateDataSet(DataProvider dataProvider)
{
var filter = GetFilter<PositionsReportFilter>();
var databaseService = new RubezhDAL.DataClasses.DbService();
dataProvider.LoadCache();
Guid organisationUID = Guid.Empty;
var organisations = dataProvider.Organisations.Where(org => filter.User == null || filter.User.IsAdm || org.Value.Item.UserUIDs.Any(y => y == filter.User.UID));
if (!filter.UseArchive)
organisations = organisations.Where(org => !org.Value.IsDeleted);
if (filter.Organisations.IsEmpty())
{
if (filter.IsDefault)
organisationUID = organisations.FirstOrDefault().Key;
}
else
{
organisationUID = organisations.FirstOrDefault(org => org.Key == filter.Organisations.FirstOrDefault()).Key;
}
filter.Organisations = new List<Guid>() { organisationUID };
var positionFilter = new PositionFilter()
{
OrganisationUIDs = filter.Organisations ?? new List<Guid>(),
UIDs = filter.Positions ?? new List<Guid>(),
LogicalDeletationType = filter.UseArchive ? LogicalDeletationType.All : LogicalDeletationType.Active,
};
var positions = GetPosition(dataProvider, filter);
var ds = new PositionsDataSet();
if (positions != null)
positions.ForEach(position =>
{
var row = ds.Data.NewDataRow();
row.Organisation = position.Organisation;
row.Position = position.Item.Name;
row.Description = position.Item.Description;
ds.Data.AddDataRow(row);
});
return ds;
}
public async Task <ActionResult <List <Position_PositionDTO> > > List([FromBody] Position_PositionFilterDTO Position_PositionFilterDTO)
{
if (UnAuthorization)
{
return(Forbid());
}
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
PositionFilter PositionFilter = ConvertFilterDTOToFilterEntity(Position_PositionFilterDTO);
PositionFilter = await PositionService.ToFilter(PositionFilter);
List <Position> Positions = await PositionService.List(PositionFilter);
List <Position_PositionDTO> Position_PositionDTOs = Positions
.Select(c => new Position_PositionDTO(c)).ToList();
return(Position_PositionDTOs);
}
private async Task <bool> HasPermission(long Id)
{
PositionFilter PositionFilter = new PositionFilter();
PositionFilter = await PositionService.ToFilter(PositionFilter);
if (Id == 0)
{
}
else
{
PositionFilter.Id = new IdFilter {
Equal = Id
};
int count = await PositionService.Count(PositionFilter);
if (count == 0)
{
return(false);
}
}
return(true);
}
public async Task <List <Position> > List(PositionFilter PositionFilter)
{
try
{
List <Position> Positions = await UOW.PositionRepository.List(PositionFilter);
return(Positions);
}
catch (Exception ex)
{
if (ex.InnerException == null)
{
await Logging.CreateSystemLog(ex, nameof(PositionService));
throw new MessageException(ex);
}
else
{
await Logging.CreateSystemLog(ex.InnerException, nameof(PositionService));
throw new MessageException(ex.InnerException);
}
}
}
public async Task <int> Count(PositionFilter PositionFilter)
{
try
{
int result = await UOW.PositionRepository.Count(PositionFilter);
return(result);
}
catch (Exception ex)
{
if (ex.InnerException == null)
{
await Logging.CreateSystemLog(ex, nameof(PositionService));
throw new MessageException(ex);
}
else
{
await Logging.CreateSystemLog(ex.InnerException, nameof(PositionService));
throw new MessageException(ex.InnerException);
}
}
}
private IQueryable <PositionDAO> DynamicFilter(IQueryable <PositionDAO> query, PositionFilter filter)
{
if (filter == null)
{
return(query.Where(q => false));
}
query = query.Where(q => !q.DeletedAt.HasValue);
if (filter.CreatedAt != null && filter.CreatedAt.HasValue)
{
query = query.Where(q => q.CreatedAt, filter.CreatedAt);
}
if (filter.UpdatedAt != null && filter.UpdatedAt.HasValue)
{
query = query.Where(q => q.UpdatedAt, filter.UpdatedAt);
}
if (filter.Id != null && filter.Id.HasValue)
{
query = query.Where(q => q.Id, filter.Id);
}
if (filter.Code != null && filter.Code.HasValue)
{
query = query.Where(q => q.Code, filter.Code);
}
if (filter.Name != null && filter.Name.HasValue)
{
query = query.Where(q => q.Name, filter.Name);
}
if (filter.StatusId != null && filter.StatusId.HasValue)
{
query = query.Where(q => q.StatusId, filter.StatusId);
}
query = OrFilter(query, filter);
return(query);
}
private IQueryable <PositionDAO> DynamicOrder(IQueryable <PositionDAO> query, PositionFilter filter)
{
switch (filter.OrderType)
{
case OrderType.ASC:
switch (filter.OrderBy)
{
case PositionOrder.Id:
query = query.OrderBy(q => q.Id);
break;
case PositionOrder.Code:
query = query.OrderBy(q => q.Code);
break;
case PositionOrder.Name:
query = query.OrderBy(q => q.Name);
break;
case PositionOrder.Status:
query = query.OrderBy(q => q.StatusId);
break;
}
break;
case OrderType.DESC:
switch (filter.OrderBy)
{
case PositionOrder.Id:
query = query.OrderByDescending(q => q.Id);
break;
case PositionOrder.Code:
query = query.OrderByDescending(q => q.Code);
break;
case PositionOrder.Name:
query = query.OrderByDescending(q => q.Name);
break;
case PositionOrder.Status:
query = query.OrderByDescending(q => q.StatusId);
break;
}
break;
}
query = query.Skip(filter.Skip).Take(filter.Take);
return(query);
}
public void Initialize()
{
DepartmentFilter = new DepartmentFilter()
{
OrganisationUIDs = Filter.OrganisationUIDs,
LogicalDeletationType = Filter.LogicalDeletationType
};
PositionFilter = new PositionFilter()
{
OrganisationUIDs = Filter.OrganisationUIDs,
LogicalDeletationType = Filter.LogicalDeletationType
};
AdditionalColumnTypeFilter = new AdditionalColumnTypeFilter()
{
OrganisationUIDs = Filter.OrganisationUIDs,
LogicalDeletationType = Filter.LogicalDeletationType
};
CardFilter = new CardFilter()
{
OrganisationUIDs = Filter.OrganisationUIDs,
EmployeeFilter = Filter.EmployeeFilter,
};
AccessTemplateFilter = new AccessTemplateFilter()
{
OrganisationUIDs = Filter.OrganisationUIDs,
LogicalDeletationType = Filter.LogicalDeletationType
};
PassCardTemplateFilter = new PassCardTemplateFilter()
{
OrganisationUIDs = Filter.OrganisationUIDs,
LogicalDeletationType = Filter.LogicalDeletationType
};
InitializeEmployeeFilter();
DepartmentsViewModel.Initialize(DepartmentFilter);
PositionsViewModel.Initialize(PositionFilter);
AdditionalColumnTypesViewModel.Initialize(AdditionalColumnTypeFilter);
CardsViewModel.Initialize(CardFilter);
AccessTemplatesViewModel.Initialize(AccessTemplateFilter);
PassCardTemplatesViewModel.Initialize(PassCardTemplateFilter);
OrganisationsViewModel.Initialize(Filter.LogicalDeletationType);
EmployeesViewModel.Initialize(EmployeeFilter);
}
public OperationResult<List<ShortPosition>> GetPositionList(Guid clientUID, PositionFilter filter)
{
return SafeOperationCall(clientUID, () => RubezhService.GetPositionList(clientUID, filter), "GetPositionList");
}
public async Task <IHttpActionResult> GetPositions(PositionFilter filter)
{
var positions = await positionManager.GetPositionsAsync(filter);
return(Ok(positions));
}
public OperationResult<List<ShortPosition>> GetPositionList(PositionFilter filter)
{
return SafeOperationCall(() =>
{
var rubezhService = RubezhServiceFactory.Create(TimeSpan.FromMinutes(10));
using (rubezhService as IDisposable)
return rubezhService.GetPositionList(RubezhServiceFactory.UID, filter);
}, "GetPositionList");
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public void testFirstTokenPositionIncrement() throws Exception
public virtual void testFirstTokenPositionIncrement()
{
TokenStream ts = new MockTokenizer(new StringReader("a abc"), MockTokenizer.WHITESPACE, false);
ts = new PositionFilter(ts); // All but first token will get 0 position increment
EdgeNGramTokenFilter filter = new EdgeNGramTokenFilter(TEST_VERSION_CURRENT, ts, EdgeNGramTokenFilter.Side.FRONT, 2, 3);
// The first token "a" will not be output, since it's smaller than the mingram size of 2.
// The second token on input to EdgeNGramTokenFilter will have position increment of 0,
// which should be increased to 1, since this is the first output token in the stream.
assertTokenStreamContents(filter, new string[] {"ab", "abc"}, new int[] {2, 2}, new int[] {5, 5}, new int[] {1, 0});
}
/// <summary>
/// 执行过滤器
/// </summary>
/// <returns></returns>
private static MiddlewareParameter Execute(MiddlewareParameter middlareResult)
{
//全局开始过滤器
GlobalPreFilters.ForEach(filter => filter(middlareResult));
//处理文本消息
if (middlareResult.Input.RequestBaseModel.MsgType == Configurations.Current.MessageType.Text)
{
var textReq = middlareResult.Input.GetRequestModel <TextRequest>();
TextFilters.Execute(textReq, middlareResult);
}
//处理图片消息
if (middlareResult.Input.RequestBaseModel.MsgType == Configurations.Current.MessageType.Image)
{
var imageReq = middlareResult.Input.GetRequestModel <ImageRequest>();
ImageFilters.Execute(imageReq, middlareResult);
}
//位置信息
if (middlareResult.Input.RequestBaseModel.MsgType == Configurations.Current.MessageType.Location)
{
var locationReq = middlareResult.Input.GetRequestModel <LocationRequest>();
LocationFilters.Execute(locationReq, middlareResult);
}
//事件
if (middlareResult.Input.RequestBaseModel.MsgType == Configurations.Current.MessageType.Event)
{
var eb = middlareResult.Input.GetRequestModel <EventBase>();
//普通过滤器
EventFileters.Execute(eb, middlareResult);
if (eb.Event == Configurations.Current.EventType.Click)
{
//单击菜单事件
var clickReq = middlareResult.Input.GetRequestModel <ClickMenuRequest>();
ClickFilters.Execute(clickReq, middlareResult);
}
if (eb.Event == Configurations.Current.EventType.Scan)
{
//扫描二维码事件
var scanReq = middlareResult.Input.GetRequestModel <ScanQrRequest>();
ScanQrFilters.Execute(scanReq, middlareResult);
}
if (eb.Event == Configurations.Current.EventType.Location)
{
//位置事件
var positionReq = middlareResult.Input.GetRequestModel <PositionRequest>();
PositionFilter.Execute(positionReq, middlareResult);
}
}
//执行 语音识别结果 过滤器
if (middlareResult.Input.RequestBaseModel.MsgType == Configurations.Current.MessageType.Voice)
{
var voiceReq = middlareResult.Input.GetRequestModel <VoiceRequest>();
VoiceFilters.Execute(voiceReq, middlareResult);
}
//全局结束过滤器
GlobalEndFilters.ForEach(filter => filter(middlareResult));
return(middlareResult);
}
public ClientInterestArea(ClientEntity attachedEntity) : base(attachedEntity)
{
m_PositionFilter = FilterFactory.CreatePositionFilter(attachedEntity);
m_EnterExitFilter = EnterExitFilterFactory.CreateEnterExitFilter(attachedEntity);
m_SubscriptionManagementFiber.Start();
}
/// <summary>
/// Moves the avatar towards the cubes.
/// </summary>
private void MoveTowardCubes()
{
var myTransform = EnableAvatarManipulation ? transform.parent.transform : transform;
// Resets the guide position whenever the avatar has moved by a significant distance.
if ((myTransform.position - m_GuidePosition).magnitude > k_MaxAvatarDistanceInMeter)
{
m_GuidePosition = myTransform.position;
}
// Limits the look rotation because the andy's origin is at its feet.
Vector3 newLookAtPosition = new Vector3(m_CubeObjects[0].transform.position.x,
myTransform.position.y, m_CubeObjects[0].transform.position.z);
myTransform.LookAt(newLookAtPosition, Vector3.up);
// Limits the new postion in the Y axis, so the andy doesn't go flying everywhere.
Vector3 newPos = new Vector3(m_CubeObjects[0].transform.position.x,
m_CubeObjects[0].transform.position.y, m_CubeObjects[0].transform.position.z);
// Measures the distance to the new position.
float currentDistance = Vector3.Distance(m_GuidePosition, newPos);
float interpolationTime = BaseSpeed * Time.deltaTime;
Vector3 interpolatedPos = Vector3.MoveTowards(m_GuidePosition, newPos, interpolationTime);
Vector3 backupPos = interpolatedPos;
Vector3 raycastStartPos = interpolatedPos;
raycastStartPos.y += k_RaycastStartOffsetInMeter;
Vector3 raycastEndPos = interpolatedPos;
raycastEndPos.y += k_RaycastEndOffsetInMeter;
// Raycasts from the avatar's position downwards to find a hit point in the depth map.
raycastStartPos = AvatarNavigationHelper.RaycastDepth(DepthSource.DepthArray,
raycastStartPos, raycastEndPos, k_RaycastStepSizeInMeter);
// Uses the hit point, if a valid hit point has been detected.
bool isRaycastStartPosInvalid =
float.IsInfinity(raycastStartPos.x) ||
float.IsInfinity(raycastStartPos.y) ||
float.IsInfinity(raycastStartPos.z) ||
float.IsNaN(raycastStartPos.x) ||
float.IsNaN(raycastStartPos.y) ||
float.IsNaN(raycastStartPos.z);
interpolatedPos = isRaycastStartPosInvalid ? interpolatedPos : raycastStartPos;
// Never let Andy go over the pawn for more than k_MaxHeightAbovePawnInMeter.
if (interpolatedPos.y > newPos.y + k_MaxHeightAbovePawnInMeter)
{
interpolatedPos.y = newPos.y + k_MaxHeightAbovePawnInMeter;
}
// Normalizes the speed of the avatar after adjusting the trajectory based on depth.
interpolatedPos = Vector3.MoveTowards(m_GuidePosition, interpolatedPos, interpolationTime);
float distanceChange = Vector3.Distance(m_GuidePosition, interpolatedPos);
if (distanceChange < k_MinimumDistanceChange)
{
interpolatedPos = backupPos;
}
m_GuidePosition = interpolatedPos;
PositionFilter posFilter = GetComponent <PositionFilter>();
if (posFilter != null)
{
// Smoothes the trajectory of the avatar using a position filter.
interpolatedPos = posFilter.Filter(interpolatedPos);
}
myTransform.position = interpolatedPos;
currentDistance = Vector3.Distance(interpolatedPos, newPos);
if (currentDistance < k_DistanceToPickUp ||
m_CubeObjects[0].transform.position.y < -k_MaxChaseDistanceInMeter)
{
GameObject cubeToRemove = m_CubeObjects[0];
m_CubeObjects.Remove(cubeToRemove);
Destroy(cubeToRemove);
currentDistance = 0;
LookAtCamera();
}
}
public JsonResult GetPositionsFilter(bool isWithDeleted)
{
var filter = new PositionFilter { User = ClientManager.CurrentUser };
if (isWithDeleted)
{
filter.LogicalDeletationType = LogicalDeletationType.All;
}
var positionViewModel = new PositionsViewModel();
positionViewModel.Initialize(filter);
dynamic result = new
{
page = 1,
total = 100,
records = 100,
rows = positionViewModel.Organisations,
};
return Json(result, JsonRequestBehavior.AllowGet);
}
public static IEnumerable<ShortPosition> Get(PositionFilter filter)
{
var operationResult = ClientManager.RubezhService.GetPositionList(filter);
return Common.ThrowErrorIfExists(operationResult);
}
public OperationResult<List<ShortPosition>> GetPositionList(Guid clientUID, PositionFilter filter)
{
OperationResult<List<ShortPosition>> result;
using (var databaseService = new RubezhDAL.DataClasses.DbService())
{
result = databaseService.PositionTranslator.ShortTranslator.Get(filter);
}
return result;
}
