public static void ParseOptionalFields(EmoteCategory category, string fields, Dictionary <EmoteSetField, string> fieldDict)
{
DefaultFields.TryGetValue(category, out var defaultFields);
if (defaultFields == null)
{
Console.WriteLine($"EmoteSet_Line.ParseOptionalFields({category}): couldn't find default field for {category}");
return;
}
// custom parsers
var tokens = new List <string>()
{
fields
};
if (defaultFields.Count > 1)
{
tokens = GetSubTokens(fields);
if (tokens.Count > defaultFields.Count)
{
Console.WriteLine($"Warning: EmoteSet_LineParseOptionalFields({category}): {fields} contains more than default # of fields");
}
}
for (var i = 0; i < tokens.Count && i < defaultFields.Count; i++)
{
var token = tokens[i];
var defaultField = defaultFields[i];
switch (defaultField)
{
case EmoteSetField.WeenieClassId:
var wcid = Parser.TryParseWeenieClassId(token);
if (wcid != null)
{
fieldDict.Add(EmoteSetField.WeenieClassId, wcid.ToString());
}
break;
case EmoteSetField.VendorType:
var vendorType = Parser.TryParseVendorType(token);
if (vendorType != null)
{
fieldDict.Add(EmoteSetField.VendorType, ((int)vendorType).ToString());
}
break;
default:
fieldDict.Add(defaultField, token);
break;
}
}
}
public static List <Log> UpdateSite(ClientContext ctx, DefaultFields defaultFields)
{
const string TaxonomyFieldType = "TaxonomyFieldType";
const string TaxonomyFieldTypeMulti = "TaxonomyFieldTypeMulti";
Web web = ctx.Web;
try
{
Log.ClearLog();
ctx.Load(web);
FieldCollection fields = web.Fields;
ctx.Load(fields, tcol => tcol.Where(t => t.TypeAsString == TaxonomyFieldType || t.TypeAsString == TaxonomyFieldTypeMulti));
ctx.ExecuteQuery();
/// Update Columns
foreach (var column in defaultFields)
{
Field field = GetField(column.InternalName, fields);
if (field == null)
{
Log.Error(web.Url, "", column.InternalName, "Invalid Field Name");
}
else
{
TaxonomyField taxonomyField = ctx.CastTo <TaxonomyField>(field);
if (taxonomyField.AllowMultipleValues)
{
TaxonomyFieldValueCollection taxonomyFieldValues = new TaxonomyFieldValueCollection(ctx, "", field);
taxonomyFieldValues.PopulateFromLabelGuidPairs(column.TermLabel + "|" + column.Guid);
var validatedValues = taxonomyField.GetValidatedString(taxonomyFieldValues);
ctx.ExecuteQuery();
taxonomyField.DefaultValue = validatedValues.Value;
}
else
{
TaxonomyFieldValue taxonomyFieldValue = new TaxonomyFieldValue();
taxonomyFieldValue.WssId = -1;
taxonomyFieldValue.Label = column.TermLabel;
taxonomyFieldValue.TermGuid = column.Guid;
var validatedValue = taxonomyField.GetValidatedString(taxonomyFieldValue);
ctx.ExecuteQuery();
taxonomyField.DefaultValue = validatedValue.Value;
}
taxonomyField.UpdateAndPushChanges(true);
ctx.ExecuteQuery();
}
}
}
catch (Exception ex)
{
Log.Error(web.Url, "", "", ex.Message);
}
return(Log.GetLog());
}
protected override IExpressionTree CorrectFields(object entity, IExpressionTree fields)
{
if (fields == null || fields.Children.Count == 0)
{
return(DefaultFields.GetOrAdd(entity.GetType(), t => new ExpressionParser().ParseTree(t, "id,name,url")));
}
return(base.CorrectFields(entity, fields));
}
public static List <PropertyInfo> GetProperties(Type type, DefaultFields mode)
{
if (type == null)
{
throw new ArgumentException(nameof(type));
}
// First requirement is that properties and getters must be public.
var properties = type
.GetOutmostProperties()
.Where(p => p.PropertyInfo.CanRead && p.PropertyInfo.GetGetMethod(true).IsPublic)
.OrderBy(p => p.Token)
.Select(i => i.PropertyInfo);
switch (mode)
{
case DefaultFields.AllIncludingReadonly:
return(properties
.Where(p => p.GetCustomAttribute <FieldIgnoreAttribute>() == null)
.ToList());
case DefaultFields.AllExcludingReadonly:
return(properties.Where(p =>
{
if (p.GetCustomAttribute <FieldIgnoreAttribute>() != null)
{
return false;
}
if (p.GetCustomAttribute <FieldAttribute>() != null)
{
return true;
}
return p.CanWrite && p.GetSetMethod(true).IsPublic;
}).ToList());
case DefaultFields.None:
return(properties.Where(p =>
{
if (p.GetCustomAttribute <FieldIgnoreAttribute>() != null)
{
return false;
}
return p.GetCustomAttribute <FieldAttribute>() != null;
}).ToList());
default:
throw new ArgumentOutOfRangeException(nameof(mode), mode, "Invalid DefaultFields value.");
}
}
public static List <Log> Update(ClientContext ctx, DefaultFields defaultFields)
{
//return Update(ctx, defaultFields, true);
//}
//static public List<Log> Update(ClientContext ctx, DefaultFields defaultFields, bool pushToLibrary)
//{
Web web = ctx.Web;
try
{
Log.ClearLog();
WebCollection webs = web.Webs;
ListCollection lists = web.Lists;
FieldCollection fields = web.Fields;
ctx.Load(web);
ctx.Load(webs);
ctx.Load(lists, doclist => doclist.Where(doc => doc.BaseTemplate == 101));
//ctx.Load(fields, tcol => tcol.Include(t => t.InternalName, t => t.DefaultValue), tcol => tcol.Where(t => t.TypeAsString == "TaxonomyFieldType" || t.TypeAsString == "TaxonomyFieldTypeMulti"));
ctx.Load(fields, tcol => tcol.Where(t => t.TypeAsString == "TaxonomyFieldType" || t.TypeAsString == "TaxonomyFieldTypeMulti"));
ctx.ExecuteQuery();
defaultFields = UpdateSite(ctx, web, fields, defaultFields, false);
foreach (List list in lists)
{
UpdateList(ctx, web, list.Title, defaultFields);
}
foreach (Web subweb in webs)
{
ListCollection subwebLists = subweb.Lists;
ctx.Load(subwebLists, doclist => doclist.Where(dl => dl.BaseTemplate == 101));
ctx.ExecuteQuery();
foreach (List list in subwebLists)
{
//Console.WriteLine(subweb.Title + " " + list.Title);
UpdateList(ctx, subweb, list.Title, defaultFields);
}
}
// Push update of status field, as users isn't able to set column default value on library without it, due to some strange behavior from Microsoft
PushStatusFieldUpdate(ctx, web, fields);
}
catch (Exception ex)
{
Log.Error(ctx.Web.Url, "", "", ex.Message);
}
return(Log.GetLog());
}
public static List <Log> UpdateNewLibrary(ClientContext ctx, string listTitle)
{
Web web = ctx.Web;
try
{
Log.ClearLog();
List list = web.Lists.GetByTitle(listTitle);
FieldCollection fields = list.Fields;
ctx.Load(web);
ctx.Load(list);
ctx.Load(fields, tcol => tcol.Include(t => t.InternalName, t => t.DefaultValue), tcol => tcol.Where(t => t.TypeAsString == "TaxonomyFieldType" || t.TypeAsString == "TaxonomyFieldTypeMulti"));
ctx.ExecuteQuery();
DefaultFields defaultFields = new DefaultFields();
DefaultField defaultField;
foreach (Field field in fields)
{
defaultField = new DefaultField();
defaultField.InternalName = field.InternalName;
defaultFields.Add(defaultField);
}
defaultFields = UpdateSite(ctx, web, fields, defaultFields, true);
// Remove fields with empty defaultvalues
DefaultFields dfs = new DefaultFields();
DefaultField df;
foreach (DefaultField field in defaultFields)
{
if (!String.IsNullOrEmpty(field.Guid))
{
df = new DefaultField();
df.Guid = field.Guid;
df.InternalName = field.InternalName;
df.OriginGuid = field.OriginGuid;
df.TermItem = field.TermItem;
dfs.Add(df);
}
}
UpdateList(ctx, web, list.Title, dfs);
}
catch (Exception ex)
{
Log.Error(ctx.Web.Url, "", "", ex.Message);
}
return(Log.GetLog());
}
public static void ParseOptionalFields(EmoteType type, string fields, Dictionary <EmoteField, string> fieldDict)
{
DefaultFields.TryGetValue(type, out var defaultFields);
if (defaultFields == null)
{
Console.WriteLine($"ParseOptionalFields({type}): couldn't find default field for {type}");
return;
}
// custom parsers
var tokens = new List <string>()
{
fields
};
if (defaultFields.Count > 1)
{
tokens = GetSubTokens(fields);
if (tokens.Count > defaultFields.Count)
{
Console.WriteLine($"Warning: ParseOptionalFields({type}): {fields} contains more than default # of fields");
}
}
for (var i = 0; i < tokens.Count && i < defaultFields.Count; i++)
{
var token = tokens[i];
var defaultField = defaultFields[i];
switch (defaultField)
{
case EmoteField.Amount:
var amount = token;
if (token.Equals("false", StringComparison.OrdinalIgnoreCase))
{
amount = "0";
}
else if (token.Equals("true", StringComparison.OrdinalIgnoreCase))
{
amount = "1";
}
fieldDict.Add(EmoteField.Amount, amount);
break;
case EmoteField.CharacterTitle:
var title = Parser.TryParseCharacterTitle(token);
if (title != null)
{
fieldDict.Add(EmoteField.Amount, ((int)title).ToString());
}
break;
case EmoteField.PropertyAttributeStat:
var propAttr = Parser.TryParsePropertyAttribute(token);
if (propAttr != null)
{
fieldDict.Add(EmoteField.Stat, ((int)propAttr).ToString());
}
break;
case EmoteField.PropertyAttribute2ndStat:
var propVital = Parser.TryParsePropertyAttribute2nd(token);
if (propVital != null)
{
fieldDict.Add(EmoteField.Stat, ((int)propVital).ToString());
}
break;
case EmoteField.PropertyBoolStat:
var propBool = Parser.TryParsePropertyBool(token);
if (propBool != null)
{
fieldDict.Add(EmoteField.Stat, ((int)propBool).ToString());
}
break;
case EmoteField.PropertyFloatStat:
var propFloat = Parser.TryParsePropertyFloat(token);
if (propFloat != null)
{
fieldDict.Add(EmoteField.Stat, ((int)propFloat).ToString());
}
break;
case EmoteField.PropertyIntStat:
var propInt = Parser.TryParsePropertyInt(token);
if (propInt != null)
{
fieldDict.Add(EmoteField.Stat, ((int)propInt).ToString());
}
break;
case EmoteField.PropertyInt64Stat:
var propInt64 = Parser.TryParsePropertyInt64(token);
if (propInt64 != null)
{
fieldDict.Add(EmoteField.Stat, ((int)propInt64).ToString());
}
break;
case EmoteField.PropertyStringStat:
var propStr = Parser.TryParsePropertyString(token);
if (propStr != null)
{
fieldDict.Add(EmoteField.Stat, ((int)propStr).ToString());
}
break;
case EmoteField.SkillStat:
var skill = Parser.TryParseSkill(token);
if (skill != null)
{
fieldDict.Add(EmoteField.Stat, ((int)skill).ToString());
}
break;
case EmoteField.Percent:
var percent = Parser.TryParsePercent(token, out _);
if (percent != null)
{
fieldDict.Add(EmoteField.Percent, percent.ToString());
}
break;
case EmoteField.Range:
if (!RangeTypes.TryGetValue(type, out var rangeType))
{
Console.WriteLine($"Emote_Line.ParseOptionalTypes({type}) couldn't find RangeType");
break;
}
var range = Parser.TryParseRange(token, rangeType, out _);
if (range != null)
{
if (range.Min != null)
{
fieldDict.Add(EmoteField.Min, range.Min.ToString());
}
if (range.Max != null)
{
fieldDict.Add(EmoteField.Max, range.Max.ToString());
}
}
break;
case EmoteField.RangeFloat:
if (!RangeTypes.TryGetValue(type, out rangeType))
{
Console.WriteLine($"Emote_Line.ParseOptionalTypes({type}) couldn't find RangeType");
break;
}
var rangeFloat = Parser.TryParseRangeFloat(token, rangeType, out _);
if (rangeFloat != null)
{
if (rangeFloat.Min != null)
{
fieldDict.Add(EmoteField.MinFloat, rangeFloat.Min.ToString());
}
if (rangeFloat.Max != null)
{
fieldDict.Add(EmoteField.MaxFloat, rangeFloat.Max.ToString());
}
}
break;
case EmoteField.Range64:
if (!RangeTypes.TryGetValue(type, out rangeType))
{
Console.WriteLine($"Emote_Line.ParseOptionalTypes({type}) couldn't find RangeType");
break;
}
var range64 = Parser.TryParseRange64(token, rangeType, out _);
if (range64 != null)
{
if (range64.Min != null)
{
fieldDict.Add(EmoteField.Min64, range64.Min.ToString());
}
if (range64.Max != null)
{
fieldDict.Add(EmoteField.Max64, range64.Max.ToString());
}
}
break;
case EmoteField.WeenieClassId:
var wcid = Parser.TryParseWeenieClassId(token);
if (wcid != null)
{
fieldDict.Add(EmoteField.WeenieClassId, wcid.ToString());
}
break;
case EmoteField.Angles:
var angles = Parser.TryParseQuaternion(token);
if (angles != null)
{
AddAngles(angles.Value, fieldDict);
}
break;
case EmoteField.OriginAngles:
var frame = Parser.TryParseFrame(token, false);
if (frame != null)
{
AddOrigin(frame.Origin, fieldDict);
AddAngles(frame.Orientation, fieldDict);
}
else
{
var origin = Parser.TryParseVector3(token);
if (origin != null)
{
AddOrigin(origin.Value, fieldDict);
}
}
break;
case EmoteField.Position:
var pos = Parser.TryParsePosition(token);
if (pos != null)
{
fieldDict.Add(EmoteField.ObjCellId, pos.ObjCellId.ToString());
AddOrigin(pos.Frame.Origin, fieldDict);
AddAngles(pos.Frame.Orientation, fieldDict);
}
break;
case EmoteField.PScript:
var physScript = Parser.TryParsePlayScript(token);
if (physScript != null)
{
fieldDict.Add(EmoteField.PScript, ((int)physScript).ToString());
}
break;
case EmoteField.ContractId:
var contractId = Parser.TryParseContractId(token);
if (contractId != null)
{
fieldDict.Add(EmoteField.Amount, ((int)contractId).ToString());
}
break;
default:
fieldDict.Add(defaultField, token);
break;
}
}
}
private void btnConvert_Click(object sender, RoutedEventArgs e)
{
try
{
dbName = TbDb.Text;
if (!wcTable.Contains(dbName))
{
wcTable = dbName + "." + wcTable;
oltTable = dbName + "." + oltTable;
oltPortsTable = dbName + "." + oltPortsTable;
splitterTable = dbName + "." + splitterTable;
splitterPortsTable = dbName + "." + splitterPortsTable;
oltSplitterDpTable = dbName + "." + oltSplitterDpTable;
outdPairsTable = dbName + "." + outdPairsTable;
assignmentPrimlocTable = dbName + "." + assignmentPrimlocTable;
assignmentDPairsTable = dbName + "." + assignmentDPairsTable;
assignmentSplitPortTable = dbName + "." + assignmentSplitPortTable;
assignmentOltTable = dbName + "." + assignmentOltTable;
addressTable = dbName + "." + addressTable;
cablesWithOUTSpansTable = dbName + "." + cablesWithOUTSpansTable;
conTable = dbName + ".Conduits";
CABLEPAIR_Table = dbName + ".CablePairs";
dgroupTable = dbName + ".DesignationGroups";
cpdpTable = dbName + ".CABLEPAIRDESIGNATIONPAIR";
dpTable = dbName + ".DesignationPairs";
junkTable = dbName + ".JUNCTIONS";
subTable = dbName + ".Subscribers";
}
tbOracleConnectionStringText = TbOracleConnectionString.Text;
TbCmsConnectionStringText = TbCmsConnectionString.Text;
string conn = TbCmsConnectionStringText;
//get thread safe klayer
if (conn != null)
{
// Code that runs on application startup
DevExpress.Xpo.Metadata.XPDictionary dict =
new DevExpress.Xpo.Metadata.ReflectionDictionary();
dict.GetDataStoreSchema(typeof(NewNetServicesModule).Assembly);
DevExpress.Xpo.DB.IDataStore store =
DevExpress.Xpo.XpoDefault
.GetConnectionProvider(conn,
DevExpress.Xpo.DB.AutoCreateOption.SchemaAlreadyExists);
store = new DevExpress.Xpo.DB.DataCacheNode(new DevExpress.Xpo.DB.DataCacheRoot(store));
var layer = new DevExpress.Xpo.ThreadSafeDataLayer(dict, store);
Tsdl = layer;
}
if (Tsdl == null)
{
//DevExpress.XtraEditors.XtraMessageBox.Show($"Couldn't create dl");
return;
}
// MAINWorker.Connect(tsdl);
}
catch (Exception ex)
{
NewNetServices.Module.Core.StaticHelperMethods.WriteOut($"{ex}");
}
using (UnitOfWork uow = new UnitOfWork(Tsdl))
{
//using (UnitOfWork uow = MAINWorker.OptimisticLockingReadBehavior = LockingOption)
// uow = MAINWorker. LockingOption STATE = (DefaultFields
this.state = DefaultFields.GetBusinessObjectDefault <State>(uow,
new List <Tuple <string, object> >()
{
new Tuple <string, object>("ShortName", State),
new Tuple <string, object>("LongName", (State == "IA" ? "Iowa" : State == "ND"? "North Dakota" :""))
})
.Oid;
}
BtnConvert.IsEnabled = false;
Task.Factory
.StartNew(() =>
{
Task.WhenAll(BeginWork());
Dispatcher.Invoke(() => BtnConvert.IsEnabled = true);
});
//if (ToggleStep.IsChecked.HasValue && ToggleStep.IsChecked.Value)
//{
// Dispatcher.Invoke(() => ProgressBar.Maximum = 0);
// WorkBeginning?.Invoke("GID GUID Matching..", null);
// HandleStep2<Location>();
// HandleStep2<Cable>();
//}
//else
//{
}
protected override IExpressionTree CorrectFields(object entity, IExpressionTree fields) => DefaultFields.GetOrAdd(entity.GetType(), t => _fieldsParser.ParseDefaultFields(t));
static void UpdateList(ClientContext ctx, Web web, string listTitle, DefaultFields defaultFields)
{
List list = web.GetListByTitle(listTitle);
FieldCollection fields = list.Fields;
ctx.Load(fields, tcol => tcol.Include(t => t.InternalName), tcol => tcol.Where(t => t.TypeAsString == "TaxonomyFieldType" || t.TypeAsString == "TaxonomyFieldTypeMulti"));
ctx.ExecuteQuery();
List <IDefaultColumnValue> defaultValues = new List <IDefaultColumnValue>();
var currentDefaultValues = list.GetDefaultColumnValues();
string[] guid;
string[] current;
foreach (var newDefaultValue in defaultFields)
{
try
{
Field found = fields.GetFieldByInternalName(newDefaultValue.InternalName);
if (found != null)
{
bool update = true;
if (currentDefaultValues != null)
{
foreach (var currentDefaultValue in currentDefaultValues)
{
current = currentDefaultValue.Values.ToArray();
if (newDefaultValue.InternalName == current[1])
{
guid = current[2].Split('|');
//{[Value, -1;#Internal|3361fef0-33ac-457d-8a1d-df19735ffcb1]}
if (guid.Length > 0)
{
if (newDefaultValue.OriginGuid != guid[1])
{
update = false;
}
}
}
}
}
if (update)
{
var defaultColumnValue = new DefaultColumnTermValue();
defaultColumnValue.FieldInternalName = newDefaultValue.InternalName;
defaultColumnValue.FolderRelativePath = "/";
defaultColumnValue.Terms.Add(newDefaultValue.TermItem);
defaultValues.Add(defaultColumnValue);
Log.Info(web.Url, list.Title, newDefaultValue.InternalName, "");
}
}
}
catch (Exception ex)
{
Log.Error(web.Url, list.Title, newDefaultValue.InternalName, ex.Message);
}
}
if (defaultValues.Count > 0)
{
try
{
list.SetDefaultColumnValues(defaultValues);
}
catch (Exception ex)
{
Log.Error(web.Url, list.Title, "", ex.Message);
}
}
}
static DefaultFields UpdateSite(ClientContext ctx, Web web, FieldCollection fields, DefaultFields defaultFields, bool newLibrary)
{
// If newLibrary just get default values from web and fill the DefaultFields
TaxonomySession taxonomySession = TaxonomySession.GetTaxonomySession(ctx);
TermStore termStore = taxonomySession.GetDefaultSiteCollectionTermStore();
foreach (var df in defaultFields)
{
try
{
Field field = fields.GetFieldByInternalName(df.InternalName);
if (field != null)
{
if (!String.IsNullOrEmpty(field.DefaultValue))
{
string[] guid = field.DefaultValue.Split('|');
if (guid.Length > 0)
{
df.OriginGuid = guid[1];
if (newLibrary)
{
df.Guid = guid[1];
}
}
}
string termSetGuid = TermSetName.GetTermSetGuidByInternalName(df.InternalName);
TermSet termSet = termStore.GetTermSet(new Guid(termSetGuid));
Term term = termSet.GetTerm(new Guid(df.Guid));
ctx.Load(term);
if (newLibrary)
{
ctx.ExecuteQuery();
df.TermItem = term;
Log.Info(web.Url, "", df.InternalName, df.Guid);
}
else
{
bool multiValue;
TaxonomyField taxField = ctx.CastTo <TaxonomyField>(field);
try
{
multiValue = taxField.AllowMultipleValues;
}
catch
{
multiValue = false;
}
if (multiValue)
{
string defaultValue = "-1;#" + df.TermLabel + "|" + df.Guid;
//TaxonomyFieldValueCollection defaultValue = new TaxonomyFieldValueCollection()
//defaultValue.WssId = -1;
//defaultValue.Label = df.TermLabel;
//defaultValue.TermGuid = df.Guid;
//var validatedValue = taxField.GetValidatedString(defaultValue);
//ctx.ExecuteQuery();
taxField.DefaultValue = defaultValue;
taxField.Update();
ctx.ExecuteQuery();
df.TermItem = term;
Log.Info(web.Url, "", df.InternalName, defaultValue);
}
else
{
TaxonomyFieldValue defaultValue = new TaxonomyFieldValue();
defaultValue.WssId = -1;
defaultValue.Label = df.TermLabel;
defaultValue.TermGuid = df.Guid;
var validatedValue = taxField.GetValidatedString(defaultValue);
ctx.ExecuteQuery();
taxField.DefaultValue = validatedValue.Value;
taxField.Update();
ctx.ExecuteQuery();
df.TermItem = term;
Log.Info(web.Url, "", df.InternalName, validatedValue.Value);
}
}
}
}
catch (Exception ex)
{
Log.Error(web.Url, "", df.InternalName, ex.Message);
}
}
return(defaultFields);
}
