public bool Equals(JniValueMarshalerState other)
{
return(JniArgumentValue.Equals(other.JniArgumentValue) &&
ReferenceValue.Equals(other.ReferenceValue) &&
object.ReferenceEquals(PeerableValue, other.PeerableValue) &&
object.ReferenceEquals(Extra, other.Extra));
}
/// <summary>
/// Overriden. Returns a hash code for the current Object.
/// </summary>
/// <returns>A hash code for the current Object.</returns>
public override int GetHashCode()
{
switch (ValueType)
{
case ValueTypeDefinitionData.Reference:
return(ReferenceValue.GetHashCode());
case ValueTypeDefinitionData.DateTime:
return(DateTimeValue.GetHashCode());
case ValueTypeDefinitionData.Bool:
return(BoolValue.GetHashCode());
case ValueTypeDefinitionData.Float:
return(FloatValue.GetHashCode());
case ValueTypeDefinitionData.Int:
return(IntValue.GetHashCode());
case ValueTypeDefinitionData.StringNonUnicode:
return(StringNonUnicodeValue.GetHashCode());
default:
return(base.GetHashCode());
}
}
public async Task SeedAsync(ApplicationDbContext dbContext, IServiceProvider serviceProvider)
{
if (dbContext.ReferenceValues.Any())
{
if (dbContext.ReferenceValues.Any(x => x.Units == null))
{
await AddMeasuringUnits(dbContext);
return;
}
return;
}
var referenceValueNames = new List <string> {
"Albumin", "Globulin", "ALT", "AST", "g-GT", "Urea", "Creatinine", "Glucose",
};
var dogMaxReferenceValues = new List <decimal> {
44, 52, 118, 48.5m, 7, 8.9m, 124, 7.95m
};
var dogMinReferenceValues = new List <decimal> {
25, 23, 10, 8.9m, 0, 2.5m, 27, 3.89m
};
var catMaxReferenceValues = new List <decimal> {
45, 57, 100, 43m, 2, 10.7m, 141, 8.3m
};
var catMinReferenceValues = new List <decimal> {
27, 15, 20, 12, 0, 3.6m, 27, 3.9m
};
for (int i = 0; i < referenceValueNames.Count; i++)
{
var referenceValue = new ReferenceValue
{
Name = referenceValueNames[i],
AnimalType = dbContext.AnimalTypes.FirstOrDefault(at => at.Name == "Dog"),
MaxValue = dogMaxReferenceValues[i],
MinValue = dogMinReferenceValues[i],
};
await dbContext.AddAsync(referenceValue);
}
for (int i = 0; i < referenceValueNames.Count; i++)
{
var referenceValue = new ReferenceValue
{
Name = referenceValueNames[i],
AnimalType = dbContext.AnimalTypes.FirstOrDefault(at => at.Name == "Cat"),
MaxValue = catMaxReferenceValues[i],
MinValue = catMinReferenceValues[i],
};
await dbContext.AddAsync(referenceValue);
}
}
public bool Equals(JniValueMarshalerState value)
{
return(JniArgumentValue.Equals(value.JniArgumentValue) &&
ReferenceValue.Equals(value.ReferenceValue) &&
object.ReferenceEquals(PeerableValue, value.PeerableValue) &&
object.ReferenceEquals(Extra, value.Extra));
}
public void Provision(MVEntry mventry)
{
string maName = "ADMA";
ManagementAgent ma = mventry.ConnectedMAs[maName];
//begin changes
if (mventry.ConnectedMAs[maName].Connectors.Count == 0)
{
//provision new AD object
if (mventry["uid"].IsPresent && mventry["accountName"].IsPresent && mventry["ou"].IsPresent)
{
string cn = string.Format("CN={0}", mventry["uid"].StringValue);
ReferenceValue dn = mventry.ConnectedMAs[maName].EscapeDNComponent(cn).Concat(mventry["ou"].StringValue);
CSEntry adCSentry = mventry.ConnectedMAs[maName].Connectors.StartNewConnector("user");
adCSentry.DN = dn;
string pwd = GenerateRandomString(32);
adCSentry["unicodePwd"].Value = pwd;
//Log.Debug(pwd);
adCSentry["SamAccountName"].StringValue = mventry["AccountName"].StringValue;
adCSentry.CommitNewConnector();
}
}
else
{
//rename existing AD object
CSEntry adCSentry = mventry.ConnectedMAs[maName].Connectors.ByIndex[0];
ReferenceValue newDn = mventry.ConnectedMAs[maName].EscapeDNComponent(string.Format("Cn={0}", mventry["uid"].StringValue)).Concat(mventry["ou"].StringValue);
adCSentry.DN = newDn;
}
}
public ProgramState execute(ProgramState state)
{
if (state.GetSymTable().ContainsKey(id))
{
throw new Exception("Variable already declared!\n");
}
Value.Value val = null;
if (type.HasSameType(new IntType()))
{
val = new IntValue(0);
}
else if (type.HasSameType(new BoolType()))
{
val = new BoolValue(false);
}
else if (type.HasSameType(new StringType()))
{
val = new StringValue("");
}
else
{
val = new ReferenceValue(0, ((ReferenceType)type).getInner());
}
state.GetSymTable()[id] = val;
return(null);
}
public override string ToString()
{
return(string.Format("JniValueMarshalerState({0}, ReferenceValue={1}, PeerableValue=0x{2}, Extra={3})",
JniArgumentValue.ToString(),
ReferenceValue.ToString(),
RuntimeHelpers.GetHashCode(PeerableValue).ToString("x"),
Extra));
}
public Option(ReferenceValue <bool> boolReference, string optionName)
{
type = typeof(bool);
name = optionName;
this.boolReference = boolReference;
this.floatReference = new ReferenceValue <float>(() => 0f, v => { });
minValue = 0f;
maxValue = 0f;
}
public Variable GetVariableFromReference(ReferenceValue reference)
{
Variable result;
if(!TryGetVariableFromReference(reference, out result))
{
throw new KeyNotFoundException(string.Format("No variable from reference '{0}'.", reference));
}
return result;
}
public Option(ReferenceValue <float> floatReference, string optionName, float min = 0f, float max = 1f)
{
type = typeof(float);
name = optionName;
this.boolReference = new ReferenceValue <bool>(() => false, v => { });
this.floatReference = floatReference;
minValue = min;
maxValue = max;
}
/// <summary>
/// Constructor used internal
/// </summary>
/// <param name="referenceValue">referencevalue</param>
internal ComplexType(ReferenceValue referenceValue)
{
if (referenceValue == null)
{
throw new ArgumentNullException();
}
this.referenceValue = referenceValue;
}
private bool AreDNsEqual(ReferenceValue dn1, ReferenceValue dn2, ManagementAgent ma, bool strictCompare)
{
if (strictCompare)
{
Tracer.TraceInformation("performing-strict-DN-comparison");
return(dn1.ToString() == dn2.ToString());
}
else
{
Tracer.TraceInformation("performing-RFC-compliant-DN-comparison");
return(dn1.Equals(dn2));
}
}
public override BloodPressureQuery AddValueFilter(string parameterName, ReferenceValue value)
{
if (parameterName == "subject")
{
var patIdValue = value.Reference.StripFromStart("Patient/");
if (!int.TryParse(patIdValue, out var patId))
{
throw new ArgumentException("Patient Id must be an integer value");
}
return(PredicateQuery(bp => bp.PatientId == patId));
}
return(base.AddValueFilter(parameterName, value));
}
public override int GetHashCode()
{
int hash = 1;
if (valueTypeCase_ == ValueTypeOneofCase.NullValue)
{
hash ^= NullValue.GetHashCode();
}
if (valueTypeCase_ == ValueTypeOneofCase.BooleanValue)
{
hash ^= BooleanValue.GetHashCode();
}
if (valueTypeCase_ == ValueTypeOneofCase.IntegerValue)
{
hash ^= IntegerValue.GetHashCode();
}
if (valueTypeCase_ == ValueTypeOneofCase.DoubleValue)
{
hash ^= DoubleValue.GetHashCode();
}
if (valueTypeCase_ == ValueTypeOneofCase.TimestampValue)
{
hash ^= TimestampValue.GetHashCode();
}
if (valueTypeCase_ == ValueTypeOneofCase.StringValue)
{
hash ^= StringValue.GetHashCode();
}
if (valueTypeCase_ == ValueTypeOneofCase.BytesValue)
{
hash ^= BytesValue.GetHashCode();
}
if (valueTypeCase_ == ValueTypeOneofCase.ReferenceValue)
{
hash ^= ReferenceValue.GetHashCode();
}
if (valueTypeCase_ == ValueTypeOneofCase.GeoPointValue)
{
hash ^= GeoPointValue.GetHashCode();
}
if (valueTypeCase_ == ValueTypeOneofCase.ArrayValue)
{
hash ^= ArrayValue.GetHashCode();
}
if (valueTypeCase_ == ValueTypeOneofCase.MapValue)
{
hash ^= MapValue.GetHashCode();
}
hash ^= (int)valueTypeCase_;
return(hash);
}
internal static bool Compare(MVEntry mventry, CSEntry csentry, string csattributeName, string mvattributeName)
{
ReferenceValue csval = null;
ReferenceValue mvval = null;
Attrib mvAttrib = mventry[mvattributeName];
if (csattributeName == "[DN]")
{
csval = csentry.DN;
}
else
{
Attrib csAttrib = csentry[csattributeName];
if (!csAttrib.IsPresent && !mvAttrib.IsPresent)
{
return(true);
}
if (csAttrib.IsPresent ^ mvAttrib.IsPresent)
{
return(false);
}
switch (csAttrib.DataType)
{
case AttributeType.Reference:
csval = csAttrib.ReferenceValue;
break;
case AttributeType.String:
csval = csentry.MA.CreateDN(csAttrib.StringValue);
break;
default:
Tracer.TraceError("Can only compare string values as DNs");
return(false);
}
}
if (mvAttrib.DataType != AttributeType.String)
{
Tracer.TraceError("Can only compare string values as DNs");
}
mvval = csentry.MA.CreateDN(mvAttrib.StringValue);
return(mvval.Equals(csval));
}
private void ConditionalRenameConnector(ConnectedMA ma, CSEntry csentry, MVEntry mventry, Rule connectorRule)
{
Tracer.TraceInformation("enter-conditionalrenameconnector");
try
{
if (connectorRule.ConditionalRename == null)
{
return;
}
string escapedCN = null;
string replacedValue = null;
if (string.IsNullOrEmpty(connectorRule.ConditionalRename.EscapedCN))
{
Tracer.TraceInformation("no-cn-to-escape");
replacedValue = connectorRule.ConditionalRename.NewDNValue.ReplaceWithMVValueOrBlank(mventry);
}
else
{
escapedCN = ma.EscapeDNComponent(connectorRule.ConditionalRename.EscapedCN.ReplaceWithMVValueOrBlank(mventry, "")).ToString();
Tracer.TraceInformation("escaped-cn {0}", escapedCN);
replacedValue = connectorRule.ConditionalRename.NewDNValue.ReplaceWithMVValueOrBlank(mventry, escapedCN);
}
ReferenceValue newdn = ma.CreateDN(replacedValue);
ReferenceValue olddn = ma.CreateDN(csentry.DN.ToString());
Tracer.TraceInformation("old-dn '{0}'", olddn.ToString());
Tracer.TraceInformation("new-dn '{0}'", newdn.ToString());
if (this.AreDNsEqual(olddn, newdn, ma, connectorRule.ConditionalRename.StrictDNCompare))
{
Tracer.TraceInformation("no-renaming-necessary");
}
else
{
Tracer.TraceInformation("dn-rename-required");
csentry.DN = newdn;
}
}
catch (Exception ex)
{
Tracer.TraceError("error {0}", ex.GetBaseException());
throw;
}
finally
{
Tracer.TraceInformation("exit-conditionalrenameconnector");
}
}
public void HandleReferenceParam()
{
var p1 = new ReferenceValue("2");
Assert.AreEqual("2", p1.Value);
var p2 = new ReferenceValue("http://server.org/fhir/Patient/1");
Assert.AreEqual("http://server.org/fhir/Patient/1", p2.Value);
var crit = Criterium.Parse(@"paramX=http://server.org/\$4/fhir/Patient/1");
var p3 = ((UntypedValue)crit.Operand).AsReferenceValue();
Assert.AreEqual("http://server.org/$4/fhir/Patient/1", p3.Value);
}
public override bool IsLessThan(ReferenceValue obj)
{
bool result;
if (obj is PointerToElementValue)
{
PointerToElementValue ptr = obj as PointerToElementValue;
result = arr == ptr.arr && index < ptr.index;
}
else
{
result = false;
}
return(result);
}
/// <summary>
/// Determines whether the specified PropertyInstanceValueData is equal to the current PropertyInstanceValueData.
/// </summary>
/// <param name="that">The PropertyInstanceValueData to compare with the current object.</param>
/// <returns>Returns true if the specified object has the same value type and same vale as the current PropertyInstanceValueData; otherwise false.</returns>
public virtual bool Equals(PropertyInstanceValueData that)
{
// if that is null - not equal
if (ReferenceEquals(that, null))
{
return(false);
}
// if that is has same reference to me - equal
if (ReferenceEquals(this, that))
{
return(true);
}
// if that has a different value type than me - not equal
if (ValueType != that.ValueType)
{
return(false);
}
// finally - if that has the same actual value as me - equal (otherwise, not equal)
switch (ValueType)
{
case ValueTypeDefinitionData.Reference:
return(ReferenceValue.Equals(that.ReferenceValue));
case ValueTypeDefinitionData.DateTime:
return(DateTimeValue.Equals(that.DateTimeValue));
case ValueTypeDefinitionData.Bool:
return(BoolValue == that.BoolValue);
case ValueTypeDefinitionData.Float:
return(FloatValue == that.FloatValue);
case ValueTypeDefinitionData.Int:
return(IntValue == that.IntValue);
case ValueTypeDefinitionData.StringNonUnicode:
return(StringNonUnicodeValue.Equals(that.StringNonUnicodeValue));
default:
return(false);
}
}
/// <summary>
/// Recupera o valor de referência.
/// </summary>
/// <param name="referenceValue">Dados da referência do valor.</param>
/// <returns></returns>
public double GetValue(ReferenceValue referenceValue)
{
if (string.IsNullOrEmpty(referenceValue.Path))
{
return(0.0);
}
// Quebra o caminho da referencias em partes
var parts = referenceValue.Path.Split('/');
if (parts.Length < 3)
{
return(0);
}
AsseguraInicializacao();
var fabricante = parts[0];
var ferragem = parts[1];
var nomeConstante = parts[2];
Constante constante = null;
lock (_itens)
{
var item = _itens.FirstOrDefault(f =>
StringComparer.InvariantCultureIgnoreCase.Equals(f.Fabricante, fabricante) &&
StringComparer.InvariantCultureIgnoreCase.Equals(f.Nome, ferragem));
if (item != null)
{
constante = item.Constantes.FirstOrDefault(f => StringComparer.InvariantCultureIgnoreCase.Equals(f.Nome, nomeConstante));
}
}
if (constante != null)
{
return(constante.Valor);
}
return(referenceValue.DefaultValue);
}
internal void Create(string referencePath, IHDDFileReaderWriter readerWriter)
{
// ttr sample1:
ReferenceValue refVal1 = new ReferenceValue("Thickness Average", Units.um, 200);
ReferenceValue refVal2 = new ReferenceValue("Thickness Std", Units.um, 2);
ReferenceValue refVal3 = new ReferenceValue("Resistivity Average", Units.Ohmcm, 1.5);
List <IReferenceValue> referenceValues1 = new List <IReferenceValue> {
refVal1, refVal2, refVal3
};
ReferenceSample referenceSample1 = new ReferenceSample("TTR Reference 01", referenceValues1);
readerWriter.WriteToFile(referenceSample1, Path.Combine(referencePath, $"TTR_Ref_01{_fileExtension}"));
// ttr sample2:
ReferenceValue refVal11 = new ReferenceValue("Thickness Average", Units.um, 190);
ReferenceValue refVal12 = new ReferenceValue("Thickness Std", Units.um, 2);
ReferenceValue refVal13 = new ReferenceValue("Resistivity Average", Units.Ohmcm, 1.4);
List <IReferenceValue> referenceValues11 = new List <IReferenceValue> {
refVal11, refVal12, refVal13
};
ReferenceSample referenceSample11 = new ReferenceSample("TTR Reference 02", referenceValues11);
readerWriter.WriteToFile(referenceSample11, Path.Combine(referencePath, $"TTR_Ref_02{_fileExtension}"));
// ttr sample2:
ReferenceValue refVal21 = new ReferenceValue("Thickness Average", Units.um, 210);
ReferenceValue refVal22 = new ReferenceValue("Thickness Std", Units.um, 2);
ReferenceValue refVal23 = new ReferenceValue("Resistivity Average", Units.Ohmcm, 1.6);
List <IReferenceValue> referenceValues21 = new List <IReferenceValue> {
refVal21, refVal22, refVal23
};
ReferenceSample referenceSample21 = new ReferenceSample("TTR Reference 03", referenceValues21);
readerWriter.WriteToFile(referenceSample21, Path.Combine(referencePath, $"TTR_Ref_03{_fileExtension}"));
}
public override string ToString()
{
string valueString = "";
if (ReferenceValue == null)
{
valueString = "null";
}
else if (ReferenceValue.ToString().Contains("BH.oM") && !(ReferenceValue is Type))
{
valueString = ReferenceValue.GetType().GetProperty("Name").GetValue(ReferenceValue) as string;
}
valueString = string.IsNullOrWhiteSpace(valueString) ? ReferenceValue.ToString() : valueString;
// Make the text in the ValueComparisons more readable (remove camelCase and add spaces)
string comparisonText = Comparison.ToString();
var builder = new System.Text.StringBuilder();
foreach (char c in comparisonText)
{
if (Char.IsUpper(c) && builder.Length > 0)
{
builder.Append(' ');
}
builder.Append(Char.ToLower(c));
}
comparisonText = builder.ToString();
if (string.IsNullOrWhiteSpace(PropertyName) && ReferenceValue is System.Type)
{
return($"must be of type `{(ReferenceValue as Type).Name}`");
}
return($"{PropertyName} {comparisonText} {valueString}");
}
public virtual bool IsLessThan(ReferenceValue obj)
{
return false;
}
public virtual bool IsGreaterThan(ReferenceValue obj)
{
return obj is NullValue;
}
void IMVSynchronization.Provision(MVEntry mventry)
{
//get our provisioning ma from the db
string provisioningMAName = FIMConfiguration.GetProvisioningMA()["ma_name"].ToString();
XmlDocument xmldoc = FIMConfiguration.GetConfigXML(provisioningMAName, "private_configuration_xml");
XmlNodeList attributes = xmldoc.SelectNodes("//MAConfig/parameter-values/parameter");
//loop through each MA/object type selected
foreach (XmlNode attrib in attributes)
{
string param = attrib.Attributes["name"].Value;
string maName = param.Substring(0, param.LastIndexOf(" - "));
string objectType = param.Substring(param.LastIndexOf(" - ") + 3);
//if enabled, provision it
if (attrib.InnerText.Equals("1"))
{
//our ma has been enabled for provisioning, create a new csentry and add initial flows
ConnectedMA ma = mventry.ConnectedMAs[maName];
if (ma.Connectors.Count == 0)
{
CSEntry csentry = ma.Connectors.StartNewConnector(objectType);
//go and get the real anchor info, our provisioning ma
//uses a generic anchor to ensure tha flows can be
//defined for the actual anchor
XmlDocument maSchemaConfig = FIMConfiguration.GetConfigXML(maName, "dn_construction_xml");
XmlNode maSchemaRoot = maSchemaConfig.FirstChild;
//get dn for the object
List <string> anchors = new List <string>();
if (maSchemaRoot.FirstChild.Name.Equals("attribute", StringComparison.InvariantCultureIgnoreCase))
{
XmlNodeList anchorList = maSchemaConfig.SelectNodes("//dn-construction/attribute");
foreach (XmlNode anchor in anchorList)
{
anchors.Add(anchor.InnerText);
}
}
else
{
XmlNodeList anchorList = maSchemaConfig.SelectNodes("//dn-construction/dn[@object-type='" + objectType + "']/attribute");
foreach (XmlNode anchor in anchorList)
{
anchors.Add(anchor.InnerText);
}
}
//our export schema defines the initial attributes to flow
XmlDocument xmlFlows = FIMConfiguration.GetConfigXML(provisioningMAName, "export_attribute_flow_xml");
XmlNodeList flows = xmlFlows.SelectNodes("//export-attribute-flow/export-flow-set[@cd-object-type='" + maName + "']/export-flow");
foreach (XmlNode flow in flows)
{
//get the mapping for each flow defined and provision an initial flow
string csAttribName = flow.Attributes["cd-attribute"].Value;
csAttribName = csAttribName.Substring(csAttribName.LastIndexOf(" - ") + 3);
XmlNode mappingNode = flow.FirstChild;
string mappingType = mappingNode.Name;
string flowValue = null;
ValueCollection flowValues = null;
switch (mappingType)
{
case "direct-mapping":
string mvAttribName = mappingNode.FirstChild.InnerText;
if (mventry[mvAttribName].IsPresent)
{
if (mventry[mvAttribName].IsMultivalued)
{
flowValues = mventry[mvAttribName].Values;
}
else
{
//TODO: convert this to its proper type if necessary (i.e. int, boolean, etc)
flowValue = mventry[mvAttribName].Value;
}
}
break;
case "constant-mapping":
flowValue = mappingNode.FirstChild.InnerText;
break;
case "scripted-mapping":
break;
default:
throw new Exception("Unexpected mapping type encountered. Only Direct, Constant and Advanced/Scripted flows are allowed. Check flow rules and try again.");
}
if (flowValue != null || flowValues != null)
{
//calc dn if necessary
if (csAttribName.Equals("dn", StringComparison.InvariantCultureIgnoreCase))
{
//are we safe to assume that if we are calculating dn, we must
//be using flowValue and not flowValues?
string rdn = flowValue.ToString();
ReferenceValue dn = ma.EscapeDNComponent(rdn);
csentry.DN = dn;
}
else
{
try
{
if (flowValue != null)
{
csentry[csAttribName].Values.Add(flowValue);
}
else if (flowValues != null)
{
csentry[csAttribName].Values.Add(flowValues);
}
}
catch (InvalidOperationException ex)
{
if (!ex.Message.Equals("attribute " + csAttribName + " is read-only", StringComparison.InvariantCultureIgnoreCase))
{
throw;
}
else
{
//our anchor attribute is read only, set a temporary dn
if (anchors.Contains(csAttribName))
{
ReferenceValue dn = ma.EscapeDNComponent(Guid.NewGuid().ToString());
csentry.DN = dn;
}
}
}
}
}
}
//do we want to throw an error now if any writeable anchor attributes have not been set??
//otherwise they will get one on export, we will leave it that way for now
csentry.CommitNewConnector();
}
}
}
}
void IMVSynchronization.Provision(MVEntry mventry)
{
switch (mventry.ObjectType.ToLower())
{
//Person - MV Object type to scope provision of contoso users to the GALSync domain, as contact objects, under the "ExternalContacts" OU
#region case "person":
case "person":
{
bool bContactsConnected = false; // reset our boolean
bool bProv = false;
if (mventry["mail"].IsPresent) bProv = true;
maContacts = mventry.ConnectedMAs["GALSync"]; //Declares MA to Provisions
int iNumConnectorsContacts = maContacts.Connectors.Count; // count our connectors to this MA
if (bProv)
{
if (iNumConnectorsContacts > 0) bContactsConnected = true;
RDN = "CN=" + mventry["cn"].Value + ",OU=ExternalContacts" + ",DC=GALSync,DC=com";
targetDN = maContacts.CreateDN(RDN); //Created the CS DN
if (!(bContactsConnected)) //If not found while iNumConnectorsContacts
{
CSEntry = maContacts.Connectors.StartNewConnector("contact"); //Starts a new connector
CSEntry.DN = targetDN; //Sets the CS DN from targetDN
CSEntry["targetAddress"].Value = mventry["mail"].Value; //flows mail attribute MV > CS
CSEntry.CommitNewConnector(); //commits the connector to cs db
}
}
break;
}
#endregion case "person"
//GALSyncPerson - MV Obkect type to scope provision of external contacts from the GALSync.com domain to AD in Contoso under the "ExternalContacts" OU
#region case "GalSyncPerson":
case galsyncperson":
{
bool bContactsConnected = false; // reset our boolean
bool bProv = false;
if (mventry["mail"].IsPresent) bProv = true;
maContacts = mventry.ConnectedMAs["AD MA"]; //Declares MA to Provisions
int iNumConnectorsContacts = maContacts.Connectors.Count; // count our connectors to this MA
if (bProv)
{
if (iNumConnectorsContacts > 0) bContactsConnected = true;
RDN = "CN=" + mventry["cn"].Value + ",OU=ExternalContacts" + ",DC=Contoso,DC=com";
targetDN = maContacts.CreateDN(RDN); //Created the CS DN
if (!(bContactsConnected)) //If not found while iNumConnectorsContacts
{
CSEntry = maContacts.Connectors.StartNewConnector("contact"); //Starts a new connector
CSEntry.DN = targetDN; //Sets the CS DN from targetDN
CSEntry["targetAddress"].Value = mventry["mail"].Value; //flows mail attribute MV > CS
CSEntry.CommitNewConnector(); //commits the connector to cs db
}
}
break;
}
#endregion case "GalSyncPerson"
}
}
protected sealed override void OnRestoreChanges(ReferenceValue changes)
{
this.RestoreChanges((TChanges)changes);
}
public void HandleReferenceParam()
{
var p1 = new ReferenceValue("2");
Assert.AreEqual("2", p1.Value);
var p2 = new ReferenceValue("http://server.org/fhir/Patient/1");
Assert.AreEqual("http://server.org/fhir/Patient/1", p2.Value);
var crit = Criterium.Parse(@"paramX=http://server.org/\$4/fhir/Patient/1");
var p3 = ((UntypedValue)crit.Operand).AsReferenceValue();
Assert.AreEqual("http://server.org/$4/fhir/Patient/1", p3.Value);
}
protected abstract void OnRestoreChanges(ReferenceValue changes);
public override bool IsLessThan(ReferenceValue obj)
{
bool result;
if (obj is PointerToElementValue)
{
PointerToElementValue ptr = obj as PointerToElementValue;
result = arr == ptr.arr && index < ptr.index;
}
else
result = false;
return result;
}
public Notification(string key, Type type, ReferenceValue value)
{
this.key = key;
this.type = type;
this.value = value;
}
private void AddOrRenameConnector(ref ConnectedMA MA, ref GALMA MAConfig, MVEntry mventry, CSEntry csentry = null)
{
//
// All objects are provisioned as contacts
//
string cn = null;
int numberToAppend = 1;
bool successful = false;
bool extendedNameTried = false;
string extendedName = null;
string adminGroup = null;
bool provisioningAdd = false;
int cnLengthMax = 0;
string validatedName = null;
//
// Add or Rename if only SynchronizationOU is defined
//
if ((MAConfig.SynchronizationOU == null) || MAConfig.SynchronizationOU.Equals(""))
{
return;
}
if (!mventry[COMMON_NAME].IsPresent || !mventry[MAIL_NICK_NAME].IsPresent || !mventry[TARGET_ADDRESS].IsPresent)
{
LogAndThrowUnexpectedDataException("Provisioning without cn, mailNickName or targetAddress");
}
if (null == csentry)
{
provisioningAdd = true;
}
cn = mventry[COMMON_NAME].Value.ToString();
//
// Active Directory does not distinguish CNs that differ only in use of diacritical marks (accents) etc.
// whereas the sync service does. So force uniqueness by appending mailnickname to all CNs with extended
// chars if doing so does not exceed CN max length.
//
IEnumerator cnEnum = cn.GetEnumerator();
while (cnEnum.MoveNext())
{
if (Strings.AscW(cnEnum.Current.ToString()) > 127 && cn.Length + mventry[MAIL_NICK_NAME].Value.ToString().Length + 2 + RDN_TYPE.Length < AD_RDN_MAX_SIZE)
{
cn = cn + "(" + mventry[MAIL_NICK_NAME].Value.ToString() + ")";
break; // TODO: might not be correct. Was : Exit While
}
}
do
{
try {
//
// Create a DN for the new object, need UPPER case "CN=..."
//
string rdn = RDN_TYPE + cn;
ReferenceValue dn = MA.EscapeDNComponent(rdn).Concat(MAConfig.SynchronizationOU);
if (rdn.Length > AD_RDN_MAX_SIZE + RDN_TYPE.Length)
{
LogAndThrowUnexpectedDataException("RDN too long: " + rdn);
}
if (csentry == null)
{
//
// Try to add the object
//
//LoggingCs.Log("Adding " + dn.ToString());
csentry = ExchangeUtils.CreateMailEnabledContact(MA, dn, mventry[MAIL_NICK_NAME].Value.ToString(), mventry[TARGET_ADDRESS].Value.ToString());
adminGroup = GetAdminGroup(csentry);
if ((adminGroup != null))
{
//
// LegacyExhangeDN = adminGroup/cn=mailnickname-guid
//
validatedName = ValidateLegacyExhangeDN(mventry[MAIL_NICK_NAME].Value.ToCharArray());
if ((validatedName == null))
{
csentry[LEGACY_EXCHANGE_DN].Value = adminGroup + "/cn=" + System.Guid.NewGuid().ToString();
}
else
{
csentry[LEGACY_EXCHANGE_DN].Value = adminGroup + "/cn=" + validatedName + "-" + System.Guid.NewGuid().ToString();
}
}
}
else
{
//
// Try to rename the object
//
if (!csentry.DN.Equals(dn))
{
//LoggingCs.Log("Renaming " + dn.ToString());
csentry.DN = dn;
}
}
successful = true;
} catch (MissingParentObjectException ex) {
//
// Typically the admin has to perform a full/delta import
// on the target CD, or disable provisioning until all
// forests are imported.
//
//LoggingCs.Log("Target MA " + MA.Name + " is not imported yet. " + "Please disable provisioning until all forests " + "are imported.");
throw ex;
} catch (ObjectAlreadyExistsException ex) {
//
// If adding connector, throw away the instance to start over
//
if (provisioningAdd)
{
csentry = null;
}
//
// There is a duplicate object in the target AD,
// change the cn accordingly to avoid conflict.
//
if (!extendedNameTried)
{
extendedNameTried = true;
try {
if (mventry[DEPARTMENT].IsPresent)
{
extendedName = mventry[DEPARTMENT].Value;
}
} catch (NoSuchAttributeInObjectTypeException ex2) {
}
}
cn = null;
if (extendedName != null)
{
cn = mventry[COMMON_NAME].Value + " (" + extendedName + ")";
extendedName = null;
if (cn.Length > AD_RDN_MAX_SIZE)
{
//
// If too long, we'll try without it
//
cn = null;
}
}
if (null == cn)
{
cn = mventry[COMMON_NAME].Value;
//
// To make sure that the number appended
// will not be truncated.
// The 2 spaces reserved is for "()"
//
cnLengthMax = AD_RDN_MAX_SIZE - (numberToAppend.ToString().Length + 2);
//
// If it's too long, we are going to truncate the
// name and preserve the number appended.
//
if (cn.Length > cnLengthMax)
{
cn = cn.Substring(0, cnLengthMax);
}
cn = cn + "(" + numberToAppend.ToString() + ")";
numberToAppend = numberToAppend + 1;
if (numberToAppend > RETRY_NUM_LIMIT)
{
LogAndThrowUnexpectedDataException("Retry for " + mventry[COMMON_NAME].Value + " exceeds limit " + numberToAppend.ToString());
}
}
}
} while (!successful);
}
public void RestoreChanges(ReferenceValue changes)
{
this.OnRestoreChanges(changes);
}
public bool TryGetVariableFromReference(ReferenceValue reference, out Variable variable)
{
return globalVariables.TryGetValue(reference.Value, out variable) ||
localVariables.TryGetValue(Tuple.Create(reference.Scope, reference.Value), out variable);
}