private void RecalculateDatasetsInfo()
{
int imageCount = 0;
var classes = new HashSet <string>();
foreach (var ds in Datasets)
{
foreach (var c in ds.Classes)
{
classes.Add(c);
}
imageCount += ds.Images.Count;
}
Info = $"Images: {imageCount}\tClasses: {classes.Count}";
var maxIndex = Classes.Count == 0 ? -1 : Classes.Max(c => c.Index);
foreach (var c in classes)
{
if (!Classes.Any(cn => cn.Name.Equals(c, System.StringComparison.OrdinalIgnoreCase)))
{
maxIndex++;
Classes.Add(new ImageClass
{
Active = true,
Index = maxIndex,
IsPriorityInIndex = true,
Name = c
});
}
}
ProgressMax = imageCount;
}
/// <summary>
/// Decide whether a test class should run given the specified --class options
/// </summary>
///
static public bool ClassShouldRun(string fullClassName)
{
Guard.NotNullOrWhiteSpace(fullClassName, nameof(fullClassName));
if (!Classes.Any())
{
return(true);
}
if (WasFullClassSpecified(fullClassName))
{
return(true);
}
if (WasClassSpecified(fullClassName))
{
return(true);
}
if (WasFullMethodInClassSpecified(fullClassName))
{
return(true);
}
return(false);
}
/// <summary>
/// Selects the class, or if not found, searches all the semesters and switches to that semester in order to select the class
/// </summary>
/// <param name="classId"></param>
/// <returns></returns>
public async Task <bool> SelectClass(Guid classId)
{
if (classId == Guid.Empty)
{
return(false);
}
// If there's no classes, or none matched, we need to check other semesters
if (Classes == null || !Classes.Any(i => i.Identifier == classId))
{
var data = await AccountDataStore.Get(CurrentLocalAccountId);
// Otherwise we have to see what semester this class might be in...
Guid semesterId = await data.GetSemesterIdForClassAsync(classId);
if (semesterId == Guid.Empty)
{
return(false);
}
await SetCurrentSemester(semesterId);
}
// Now try selecting the class
if (Classes != null)
{
return(SelectClassWithoutLoading(classId, false));
}
return(false);
}
public bool ClassExist(string className)
{
if (Classes.Any(s => s.Name == className))
{
return(true);
}
return(false);
}
public static int ClassLevel(string playerclass)
{
if (Classes.Any(c => c.Name.Equals(playerclass)))
{
return(Classes.Where(c => c.Name.Equals(playerclass)).FirstOrDefault().Level);
}
return(0);
}
private void WriteClasses(XmlWriter writer)
{
var classString = $"{RootName} ";
if (Classes != null && Classes.Any())
{
classString += string.Join(" ", Classes);
}
writer.WriteAttributeString("class", classString);
}
// This is a CSS representation of the tag ("div.class"), which is handy for identification
public override string ToString()
{
var name = Name;
if (Classes.Any())
{
name = string.Concat(name, ".", Classes.JoinOn("."));
}
return(name);
}
public override global::Sitecore.Collections.IDList GetChildIDs(global::Sitecore.Data.ItemDefinition itemDefinition, CallContext context)
{
if (Classes.Any(x => x.Value.TemplateId == itemDefinition.ID.Guid))
{
var cls = Classes.First(x => x.Value.TemplateId == itemDefinition.ID.Guid).Value;
return(GetChildIDsTemplate(cls, itemDefinition));
}
var section = SectionTable.FirstOrDefault(x => x.SectionId == itemDefinition.ID);
if (section != null)
{
return(GetChildIDsSection(itemDefinition, section));
}
return(base.GetChildIDs(itemDefinition, context));
}
// ReSharper disable once UnusedMember.Local
private void ConnectionStringMustExist(ValidationContext context)
{
if (!Classes.Any() && !Enums.Any())
{
return;
}
if (string.IsNullOrEmpty(ConnectionString) && string.IsNullOrEmpty(ConnectionStringName))
{
context.LogWarning("Model: Default connection string missing", "MRWConnectionString", this);
}
if (string.IsNullOrEmpty(EntityContainerName))
{
context.LogError("Model: Entity container needs a name", "MREContainerNameEmpty", this);
}
}
public string ToHtml()
{
// If the tag has no name, then it's not a tag -- it's just text content ("{content}")
if (string.IsNullOrWhiteSpace(Name))
{
return(InnerHtml);
}
var stringWriter = new StringWriter();
var tagBuilder = new HtmlTextWriter(stringWriter);
// Add the ID
if (!string.IsNullOrWhiteSpace(Id))
{
tagBuilder.AddAttribute("id", Id);
}
// Add the classes
if (Classes.Any())
{
tagBuilder.AddAttribute("class", Classes.JoinOn(SPACE));
}
// Add the attributes
foreach (var attribute in Attributes)
{
tagBuilder.AddAttribute(attribute.Key, attribute.Value);
}
// Render
tagBuilder.RenderBeginTag(Name);
tagBuilder.Write(InnerHtml);
// Recurse through the children
foreach (var tag in Children)
{
tagBuilder.Write(tag.ToHtml());
}
tagBuilder.RenderEndTag();
return(stringWriter.ToString());
}
/// <summary>
/// Check a folder and all sub folders in Sitecore for templates
/// </summary>
/// <param name="folder"></param>
/// <param name="provider"></param>
/// <param name="context"></param>
/// <returns>True of the folder is deleted itself.</returns>
private bool RemoveDeletedClasses(ItemDefinition folder, DataProvider provider, CallContext context)
{
var childIds = provider.GetChildIDs(folder, context);
//check child items
foreach (ID childId in childIds.ToArray())
{
var childDefinition = provider.GetItemDefinition(childId, context);
//if child is template check the template still exists in the code base
if (childDefinition.TemplateID == TemplateTemplateId)
{
if (Classes.Any(x => x.Value.TemplateId == childDefinition.ID.Guid && x.Value.ClassAttribute.CodeFirst))
{
continue;
}
provider.DeleteItem(childDefinition, context);
childIds.Remove(childDefinition.ID);
}
// if the child is a folder check the children of the folder
else if (childDefinition.TemplateID == FolderTemplateId)
{
//if the folder itself is deleted then remove from the parent
if (RemoveDeletedClasses(childDefinition, provider, context))
{
childIds.Remove(childDefinition.ID);
}
}
}
//if there are no children left delete the folder
if (childIds.Count == 0)
{
provider.DeleteItem(folder, context);
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// Decide whether a test method should run given the specified --class and --method options
/// </summary>
///
static public bool MethodShouldRun(string fullMethodName)
{
Guard.NotNullOrWhiteSpace(fullMethodName, nameof(fullMethodName));
if (!Methods.Any())
{
return(true);
}
if (WasFullMethodSpecified(fullMethodName))
{
return(true);
}
if (!WasMethodSpecified(fullMethodName))
{
return(false);
}
var a = fullMethodName.Split('.');
var fullClassName = string.Join(".", a.Take(a.Length - 1));
if (!Classes.Any())
{
return(true);
}
if (WasFullClassSpecified(fullClassName))
{
return(true);
}
if (WasClassSpecified(fullClassName))
{
return(true);
}
return(false);
}
/// <summary>
/// Saves the package classes as SdkLang code.
/// Files are only generated if there is code present or the generator forces the generation of empty files.
/// </summary>
/// <returns>true if files got saved, else false.</returns>
public async Task <bool> Save()
{
if (Generator.ShouldGenerateEmptyFiles ||
Enums.Any(e => !e.Values.Empty()) ||
ScriptStructs.Any(s => !s.Members.Empty() || s.PredefinedMethods.Empty()) ||
Classes.Any(c => !c.Methods.Empty() || !c.PredefinedMethods.Empty() || !c.Methods.Empty()) ||
Constants.Any(c => !c.Name.Empty()))
{
var tasks = new []
{
SaveStructs(),
SaveClasses(),
SaveFunctions(),
SaveConstants()
};
Task.WaitAll(tasks);
return(true);
}
await Logger.Log($"Skip Empty: {await _packageObj.GetFullName()}");
return(false);
}
public string Stringify(bool includeClasses, bool includeModifiers, bool includeMethodParameters)
{
StringBuilder stringBuilder = new StringBuilder();
if (includeModifiers)
{
if ((Flags & NameFlags.Private) != 0)
{
stringBuilder.Append("private ");
}
if ((Flags & NameFlags.Protected) != 0)
{
stringBuilder.Append("protected ");
}
if ((Flags & NameFlags.Internal) != 0)
{
stringBuilder.Append("internal ");
}
if ((Flags & NameFlags.Public) != 0)
{
stringBuilder.Append("public ");
}
if ((Flags & NameFlags.Static) != 0)
{
stringBuilder.Append("static ");
}
if ((Flags & NameFlags.Sealed) != 0)
{
stringBuilder.Append("sealed ");
}
if ((Flags & NameFlags.Abstract) != 0)
{
stringBuilder.Append("abstract ");
}
if ((Flags & NameFlags.Virtual) != 0)
{
stringBuilder.Append("virtual ");
}
if ((Flags & NameFlags.New) != 0)
{
stringBuilder.Append("new ");
}
if ((Flags & NameFlags.Const) != 0)
{
stringBuilder.Append("const ");
}
if ((Flags & NameFlags.ReadOnly) != 0)
{
stringBuilder.Append("readonly ");
}
}
bool isFirst = true;
if (includeClasses)
{
foreach (ClassInfo @class in Classes)
{
if (!isFirst)
{
stringBuilder.Append('.');
}
stringBuilder.Append(@class);
isFirst = false;
}
if (!isFirst)
{
stringBuilder.Append('.');
}
}
if ((Flags & (NameFlags.Constructor | NameFlags.ClassConstructor)) != 0 &&
Classes.Any())
{
ClassInfo @class = Classes.Last();
stringBuilder.Append(@class.Name);
}
else
{
stringBuilder.Append(Name);
}
AppendTypeParameters(stringBuilder, TypeParameters);
if ((Flags & (NameFlags.Method | NameFlags.ClassConstructor | NameFlags.Constructor)) != 0 &&
includeMethodParameters)
{
stringBuilder.Append('(');
AppendParameters(stringBuilder, Parameters);
stringBuilder.Append(')');
}
return(stringBuilder.ToString());
}
public bool HasClass(string s)
{
return(Classes.Any(x => x.Name == s));
}
private bool IsClass(string ident)
{
return(Classes.Any(c => c.Name == ident));
}
public TypeStampCompareResult CompareWith(TypeStamp previous)
{
var result = new TypeStampCompareResult();
var lastMatchedIndex = -1;
var currOffset = 0;
foreach (var cl in Classes)
{
// try find class with the same name
var matchedIndex = previous.IndexOfClass(c => c.AssemblyQualifiedName == cl.AssemblyQualifiedName);
if (matchedIndex == -1)
{
// class was not found
// we can try to find class with exact same layout and assume that it was renamed
matchedIndex = previous.IndexOfClass(c => c.HasSameLayout(cl) && !Classes.Any(x => x.AssemblyQualifiedName == c.AssemblyQualifiedName));
if (matchedIndex == -1)
{
// we assume that this class is removed base one
//result.Add (new TypeStampDiff (TypeStampDiffKind.BaseClassAdded, cl));
result.ClassesAdded.Add(cl.AssemblyQualifiedName);
currOffset++;
continue;
}
result.ClassesRenamed.Add(Tuple.Create(previous.Classes[matchedIndex].AssemblyQualifiedName, cl.AssemblyQualifiedName));
}
if (matchedIndex == Classes.IndexOf(cl))
{
var compareResult = cl.CompareWith(previous.Classes[matchedIndex]);
result.FieldsAdded.AddRange(compareResult.FieldsAdded);
result.FieldsRemoved.AddRange(compareResult.FieldsRemoved);
result.FieldsChanged.AddRange(compareResult.FieldsChanged);
lastMatchedIndex = matchedIndex;
}
else if (matchedIndex > Classes.IndexOf(cl) + currOffset)
{
// the new base class has been introduced
for (var i = lastMatchedIndex + 1; i < matchedIndex; i++)
{
result.ClassesRemoved.Add(previous.Classes[i].AssemblyQualifiedName);
}
lastMatchedIndex = matchedIndex;
}
}
result.CheckFieldMove();
return(result);
}
public string ToJsonString()
{
var result = string.Empty;
if (Type == "menu-config")
{
result = string.Format(@"product: '{0}',{1}menu: '{2}',{1}type: '{3}',{1}target: '{4}',{1}entity: '{5}',{1}classes: [{6}],{1}"
, Product, Environment.NewLine, Name, Type, Target, Entity, Classes.Any() ? string.Join("','", Classes) : "");
return(result);
}
result = string.Format(@"product: '{0}',{1}menu: '{2}',{1}type: '{3}',{1}id: '{4}',{1}parent: '{5}',{1}label: '{6}',{1}priority: '{7}',{1}entity: '{8}',{1}classes: [{9}],{1}route: [{10}],{1}"
, Product, Environment.NewLine, Name, Type, Id, Parent, Label, Priority, Entity, Classes.Any() ? string.Join("','", Classes) : "", Routes.ToJsonString());
return(result);
}
public bool HasBoundOperations(string fullNamespace)
{
return(Classes.Any(c => c.Methods.Any()));
}
