/// <summary>
/// Test for empty object
/// </summary>
/// <returns>bool</returns>
public bool IsEmpty()
{
return(IfcProductFilter.IsEmpty() && IfcTypeObjectFilter.IsEmpty() && IfcAssemblyFilter.IsEmpty() &&
ZoneFilter.IsEmpty() && TypeFilter.IsEmpty() && SpaceFilter.IsEmpty() &&
FloorFilter.IsEmpty() && FacilityFilter.IsEmpty() && SpareFilter.IsEmpty() &&
ComponentFilter.IsEmpty() && CommonFilter.IsEmpty());
}
public void SpaceFilterTest(string word, bool isKeep)
{
var wl = new WordLibrary();
wl.Word = word;
SpaceFilter filter = new SpaceFilter();
Assert.AreEqual(filter.IsKeep(wl), isKeep);
}
/// <summary>
/// Test Property Set Names against sheets
/// </summary>
/// <param name="testStr">Name string to test</param>
/// <param name="parent">Parent object</param>
/// <returns>bool</returns>
public bool PSetNameFilterOnSheetName(string testStr, CobieObject parent = null)
{
bool result = false;
if (!string.IsNullOrEmpty(testStr))
{
result = CommonFilter.PSetNameFilter(testStr);
if (!result)
{
if (parent == null)
{
result = false;
}
else if ((parent is Zone) && (ZoneFilter != null))
{
result = ZoneFilter.PSetNameFilter(testStr);
}
else if ((parent is AssetType) && (TypeFilter != null))
{
result = TypeFilter.PSetNameFilter(testStr);
}
else if ((parent is Space) && (SpaceFilter != null))
{
result = SpaceFilter.PSetNameFilter(testStr);
}
else if ((parent is Floor) && (FloorFilter != null))
{
result = FloorFilter.PSetNameFilter(testStr);
}
else if ((parent is Facility) && (FacilityFilter != null))
{
result = FacilityFilter.PSetNameFilter(testStr);
}
else if ((parent is Spare) && (SpareFilter != null))
{
result = SpareFilter.PSetNameFilter(testStr);
}
else if ((parent is Asset) && (ComponentFilter != null))
{
result = ComponentFilter.PSetNameFilter(testStr);
}
else
{
result = false;
}
}
}
//don't flip property sets as this excludes all the attributes, so we do not see attribute name exclusions as all property sets get excluded
//return FlipResult ? !result : result;
return(result);
}
//TODO: IfcProperty filterining on IfcObjects
/// <summary>
/// Test property Names against sheets
/// </summary>
/// <param name="testStr">Name string to test</param>
/// <param name="parent">Parent object</param>
/// <returns>bool</returns>
public bool NameFilterOnParent(string testStr, CobieObject parent = null)
{
var result = false;
if (!string.IsNullOrEmpty(testStr))
{
result = CommonFilter.NameFilter(testStr);
if (!result)
{
if (parent == null)
{
result = false;
}
else if ((parent is Zone) && (ZoneFilter != null))
{
result = ZoneFilter.NameFilter(testStr);
}
else if ((parent is AssetType) && (TypeFilter != null))
{
result = TypeFilter.NameFilter(testStr);
}
else if ((parent is Space) && (SpaceFilter != null))
{
result = SpaceFilter.NameFilter(testStr);
}
else if ((parent is Floor) && (FloorFilter != null))
{
result = FloorFilter.NameFilter(testStr);
}
else if ((parent is Facility) && (FacilityFilter != null))
{
result = FacilityFilter.NameFilter(testStr);
}
else if ((parent is Spare) && (SpareFilter != null))
{
result = SpareFilter.NameFilter(testStr);
}
else if ((parent is Asset) && (ComponentFilter != null))
{
result = ComponentFilter.NameFilter(testStr);
}
else
{
result = false;
}
}
}
return(FlipResult ? !result : result);
}
/// <summary>
/// Merge OutPutFilters
/// </summary>
/// <param name="mergeFilter">OutPutFilters</param>
public void Merge(OutPutFilters mergeFilter)
{
IfcProductFilter.MergeInc(mergeFilter.IfcProductFilter);
IfcTypeObjectFilter.MergeInc(mergeFilter.IfcTypeObjectFilter);
IfcAssemblyFilter.MergeInc(mergeFilter.IfcAssemblyFilter);
ZoneFilter.Merge(mergeFilter.ZoneFilter);
TypeFilter.Merge(mergeFilter.TypeFilter);
SpaceFilter.Merge(mergeFilter.SpaceFilter);
FloorFilter.Merge(mergeFilter.FloorFilter);
FacilityFilter.Merge(mergeFilter.FacilityFilter);
SpareFilter.Merge(mergeFilter.SpareFilter);
ComponentFilter.Merge(mergeFilter.ComponentFilter);
CommonFilter.Merge(mergeFilter.CommonFilter);
}
public async Task <IEnumerable <DbSpace> > FindAllAsync(SpaceFilter filter = null)
{
var result = await dbContext.Spaces
.Include(s => s.Spaces)
.Include(s => s.MapFile)
.Include(s => s.SpaceType)
.Where(s => s.Parent == null &&
(filter == null ||
s.OfficeId == filter.OfficeId))
.ToListAsync();
Parallel.ForEach(
result,
async(space) => await LoadNestedSpaces(space));
return(result);
}
/// <summary>
/// Clear OutPutFilters
/// </summary>
public void Clear()
{
AppliedRoles = 0;
IfcProductFilter.Clear();
IfcTypeObjectFilter.Clear();
IfcAssemblyFilter.Clear();
ZoneFilter.Clear();
TypeFilter.Clear();
SpaceFilter.Clear();
FloorFilter.Clear();
FacilityFilter.Clear();
SpareFilter.Clear();
ComponentFilter.Clear();
CommonFilter.Clear();
}
/// <summary>
/// Copy the OutPutFilters
/// </summary>
/// <param name="copyFilter">OutPutFilters to copy </param>
public void Copy(OutPutFilters copyFilter)
{
AppliedRoles = copyFilter.AppliedRoles;
IfcProductFilter.Copy(copyFilter.IfcProductFilter);
IfcTypeObjectFilter.Copy(copyFilter.IfcTypeObjectFilter);
IfcAssemblyFilter.Copy(copyFilter.IfcAssemblyFilter);
ZoneFilter.Copy(copyFilter.ZoneFilter);
TypeFilter.Copy(copyFilter.TypeFilter);
SpaceFilter.Copy(copyFilter.SpaceFilter);
FloorFilter.Copy(copyFilter.FloorFilter);
FacilityFilter.Copy(copyFilter.FacilityFilter);
SpareFilter.Copy(copyFilter.SpareFilter);
ComponentFilter.Copy(copyFilter.ComponentFilter);
CommonFilter.Copy(copyFilter.CommonFilter);
}
public async Task <Response <IEnumerable <SpaceResponse> > > FindAllAsync(SpaceFilter filter)
{
var spaces = await spaceRepository.FindAllAsync(filter);
var result = automapper.Map <IEnumerable <SpaceResponse> >(spaces);
var spaceResponses = result.ToList();
Parallel.ForEach(spaceResponses, async(space) =>
{
var response = await workplaceServiceClient.GetWorkplacesAsync(
new GetWorkplacesRequest
{
SpaceId = space.SpaceId
});
if (response.Status == ResponseResult.Success)
{
space.Workplaces =
automapper.Map <IEnumerable <WorkplaceResponse> >(response.Result);
}
});
return(new Response <IEnumerable <SpaceResponse> >(spaceResponses));
}
public static IEnumerable <(TPos, TVal)> Select <TPos, TVal>(this AlignedSpace <TPos, TVal> space, SpaceFilter <TPos, TVal> filter)
{
foreach (var(pos, val) in space)
private CommandType RunCommand(string command)
{
if (command == "--help" || command == "-?")
{
showHelp(this.cbxImportItems);
return(CommandType.Help);
}
if (command == "--version" || command == "-v")
{
Console.WriteLine("Version:" + Assembly.GetExecutingAssembly().GetName().Version);
return(CommandType.Help);
}
if (command.StartsWith("-i:"))
{
wordLibraryImport = GetImportInterface(command.Substring(3));
beginImportFile = true;
return(CommandType.Import);
}
if (command.StartsWith("-o:"))
{
wordLibraryExport = GetExportInterface(command.Substring(3));
beginImportFile = false;
return(CommandType.Export);
}
if (command.StartsWith("-c:")) //code
{
codingFile = command.Substring(3);
pattern.MappingTablePath = codingFile;
pattern.IsPinyinFormat = false;
beginImportFile = false;
return(CommandType.Coding);
}
if (command.StartsWith("-ft:")) //filter
{
var filterStrs = command.Substring(4);
Regex lenRegex = new Regex(@"len:(\d+)-(\d+)");
Regex rankRegex = new Regex(@"rank:(\d+)-(\d+)");
Regex rmRegex = new Regex(@"rm:(\w+)");
foreach (var filterStr in filterStrs.Split('|'))
{
if (lenRegex.IsMatch(filterStr))
{
var match = lenRegex.Match(filterStr);
var from = Convert.ToInt32(match.Groups[1].Value);
var to = Convert.ToInt32(match.Groups[2].Value);
var numberFilter = new LengthFilter()
{
MinLength = from, MaxLength = to
};
this.filters.Add(numberFilter);
}
else if (rankRegex.IsMatch(filterStr))
{
var match = rankRegex.Match(filterStr);
var from = Convert.ToInt32(match.Groups[1].Value);
var to = Convert.ToInt32(match.Groups[2].Value);
var rFilter = new RankFilter()
{
MinLength = from, MaxLength = to
};
this.filters.Add(rFilter);
}
else if (rmRegex.IsMatch(filterStr))
{
var match = rmRegex.Match(filterStr);
var rmType = match.Groups[1].Value;
ISingleFilter filter;
switch (rmType)
{
case "eng": filter = new EnglishFilter(); break;
case "num": filter = new NumberFilter(); break;
case "space": filter = new SpaceFilter(); break;
case "pun": filter = new EnglishPunctuationFilter(); break;
default: throw new ArgumentException("Unsupport filter type:" + rmType);
}
this.filters.Add(filter);
}
}
return(CommandType.Coding);
}
if (command.StartsWith("-ct:")) //code type
{
var codeType = command.Substring(4).ToLower();
switch (codeType)
{
case "pinyin": pattern.CodeType = CodeType.Pinyin; break;
case "wubi": pattern.CodeType = CodeType.Wubi; break;
case "zhengma": pattern.CodeType = CodeType.Zhengma; break;
case "cangjie": pattern.CodeType = CodeType.Cangjie; break;
case "zhuyin": pattern.CodeType = CodeType.TerraPinyin; break;
default: pattern.CodeType = CodeType.Pinyin; break;
}
return(CommandType.CodeType);
}
if (command.StartsWith("-r:")) //Rank
{
var rankType = command.Substring(3).ToLower();
switch (rankType)
{
case "baidu": this.wordRankGenerater = new BaiduWordRankGenerater(); break;
case "google": this.wordRankGenerater = new GoogleWordRankGenerater(); break;
default: {
var rankNumber = Convert.ToInt32(rankType);
var gen = new DefaultWordRankGenerater();
gen.ForceUse = true;
gen.Rank = rankNumber;
this.wordRankGenerater = gen;
} break;
}
return(CommandType.CodeType);
}
if (command.StartsWith("-os:")) //code type
{
var os = command.Substring(4).ToLower();
switch (os)
{
case "windows": pattern.OS = OperationSystem.Windows; break;
case "mac":
case "macos": pattern.OS = OperationSystem.MacOS; break;
case "linux":
case "unix": pattern.OS = OperationSystem.Linux; break;
default: pattern.OS = OperationSystem.Windows; break;
}
return(CommandType.OS);
}
if (command.StartsWith("-ld2:")) //ld2 encoding
{
string ecodes = command.Substring(5);
string[] arr = ecodes.Split(',');
wordEncoding = Encoding.GetEncoding(arr[0]);
if (arr.Length > 1)
{
xmlEncoding = Encoding.GetEncoding(arr[1]);
}
return(CommandType.Encoding);
}
if (command.StartsWith("-f:")) //format
{
format = command.Substring(3);
beginImportFile = false;
var sort = new List <int>();
for (int i = 0; i < 3; i++)
{
char c = format[i];
sort.Add(Convert.ToInt32(c));
}
pattern.Sort = sort;
pattern.CodeSplitString = format[3].ToString();
pattern.SplitString = format[4].ToString();
string t = format[5].ToString().ToLower();
beginImportFile = false;
if (t == "l")
{
pattern.CodeSplitType = BuildType.LeftContain;
}
if (t == "r")
{
pattern.CodeSplitType = BuildType.RightContain;
}
if (t == "b")
{
pattern.CodeSplitType = BuildType.FullContain;
}
if (t == "n")
{
pattern.CodeSplitType = BuildType.None;
}
pattern.ContainCode = (format[6].ToString().ToLower() == "y");
pattern.ContainRank = (format[8].ToString().ToLower() == "y");
return(CommandType.Format);
}
if (beginImportFile)
{
importPaths.AddRange(FileOperationHelper.GetFilesPath(command));
}
if (type == CommandType.Export)
{
exportPath = command;
}
return(CommandType.Other);
}
