/// <summary>
/// ######### ###### ################# # ##### "############" #, ####
/// ### ##### ############, ######### ### # ######### ####.
/// </summary>
/// <param name="roleId">####, # ####### ##### ######## ##### ############.</param>
protected void SaveUser(object roleId)
{
bool isNew = false;
object primaryColumnValue;
changedValues.TryGetValue("Id", out primaryColumnValue);
EntitySchema entitySchema = UserConnection.EntitySchemaManager.GetInstanceByName("VwSysAdminUnit");
Entity entity = entitySchema.CreateEntity(UserConnection);
isNew = !entity.FetchFromDB(primaryColumnValue);
if (isNew)
{
entity.SetDefColumnValues();
}
foreach (KeyValuePair <string, object> item in changedValues)
{
EntitySchemaColumn column = entitySchema.Columns.GetByName(item.Key);
object columnValue = item.Value;
if ((column.DataValueType is DateTimeDataValueType) && (item.Value != null))
{
columnValue = DataTypeUtilities.ValueAsType <DateTime>(item.Value);
}
entity.SetColumnValue(column.ColumnValueName, columnValue);
}
entity.Save();
if (isNew)
{
AddUserInRole(entity.PrimaryColumnValue, roleId);
}
}
public static void SetEntityColumnValue(Entity entity, string columnName, object columnValue)
{
var column = entity.Schema.Columns.FindByName(columnName);
if (column != null && !DataTypeUtilities.ValueIsNullOrEmpty(columnValue))
{
entity.SetColumnValue(column, columnValue);
}
}
public void set(string parameterName, object parameterValue)
{
var schema = (BaseProcessSchema)_process.Schema;
ProcessSchemaParameter parameter = schema.Parameters.GetByName(parameterName);
Type valueType = parameter.DataValueType.ValueType;
object value = DataTypeUtilities.ValueAsType(parameterValue, valueType);
MethodInfo method = GetSetValueMethod(valueType);
method.Invoke(_process, new[] { parameterName, value });
}
/// <summary>
/// ########## ######## ############### # ############ # ##### #######
/// </summary>
/// <param name="column">####### ##### ######## ### ####### ########## ########.</param>
/// <param name="value">############# ########.</param>
/// <returns>############### ########.</returns>
private static object GetColumnValue(EntitySchemaColumn column, object value)
{
if (column.DataValueType is DateTimeDataValueType)
{
return(DataTypeUtilities.ValueAsType <DateTime>(value));
}
if (column.DataValueType is LookupDataValueType)
{
return(String.IsNullOrEmpty((string)value) ? null : value);
}
return(value);
}
public virtual bool ShouldSetColumnValue(EntitySchemaColumn entitySchemaColumn, object value)
{
if (DataTypeUtilities.GetIsNullOrDBNullValue(value))
{
return(false);
}
if ((entitySchemaColumn.IsLookupType || entitySchemaColumn.IsMultiLookupType) &&
(Guid)value == Guid.Empty)
{
return(false);
}
return(true);
}
/// <summary>
/// Serializes value of the entity column.
/// </summary>
/// <param name="schemaColumn">Schema column.</param>
/// <param name="columnValue">Column value.</param>
/// <returns></returns>
public virtual object SerializeEntityColumn(CoreEntitySchemaColumn schemaColumn, object columnValue)
{
if (schemaColumn == null || columnValue == null)
{
return(string.Empty);
}
if (schemaColumn.DataValueType is BooleanDataValueType)
{
return(DataTypeUtilities.ValueAsType <bool>(columnValue));
}
if (schemaColumn.IsLookupType)
{
var primaryColumnValue = Column.Parameter(DataTypeUtilities.ValueAsType <Guid>(columnValue));
var referenceSchema = schemaColumn.ReferenceSchema;
var displayValueSelect =
new Select(UserConnection)
.Column(referenceSchema.PrimaryDisplayColumn.Name)
.From(referenceSchema.Name)
.Where(referenceSchema.PrimaryColumn.Name).IsEqual(primaryColumnValue) as Select;
return(new {
value = columnValue,
displayValue = displayValueSelect?.ExecuteScalar <string>()
});
}
if (schemaColumn.DataValueType is DateTimeDataValueType dateTimeDataValueType)
{
var dateTime = (DateTime)columnValue;
if (dateTime == DateTime.MinValue)
{
return(null);
}
if (dateTime.Kind != DateTimeKind.Unspecified)
{
columnValue = DateTime.SpecifyKind(dateTime, DateTimeKind.Unspecified);
}
string value = DateTimeDataValueType.Serialize(columnValue, TimeZoneInfo.Utc);
return(new {
dataValueType = (int)dateTimeDataValueType.ToEnum(),
value
});
}
return(DataTypeUtilities.ValueAsType <string>(columnValue));
}
/// <summary>
/// ######### ###### ################# # ##### "############".
/// </summary>
private void SaveUser()
{
object primaryColumnValue = UserConnection.CurrentUser.Id;
EntitySchema entitySchema = UserConnection.EntitySchemaManager.GetInstanceByName("VwSysAdminUnit");
Update update = new Update(UserConnection, "VwSysAdminUnit");
foreach (KeyValuePair <string, object> item in changedValues)
{
EntitySchemaColumn column = entitySchema.Columns.GetByName(item.Key);
object columnValue = item.Value;
if (column.DataValueType is DateTimeDataValueType)
{
columnValue = DataTypeUtilities.ValueAsType <DateTime>(item.Value);
}
if (column.ColumnValueName != entitySchema.PrimaryColumn.ColumnValueName)
{
update = update.Set(column.ColumnValueName, Column.Parameter(columnValue, column.DataValueType.Name));
}
}
update = update.Where(entitySchema.PrimaryColumn.ColumnValueName).IsEqual(Column.Parameter(primaryColumnValue)) as Update;
update.Execute();
}
/// <summary>
/// Validates duplicate entities.
/// </summary>
/// <param name="schemaName">Schema name.</param>
/// <param name="duplicateRecordIds">Collection of identifiers of duplicate entities.</param>
/// <param name="resolvedConflicts">Config for resolving conflicts.</param>
/// <returns>Validation result.</returns>
public ValidateDuplicatesResponse ValidateDuplicates(string schemaName, List <Guid> duplicateRecordIds,
Dictionary <string, string> resolvedConflicts)
{
ValidateDuplicatesResponse response = new ValidateDuplicatesResponse();
EntitySchema entitySchema = UserConnection.EntitySchemaManager.GetInstanceByName(schemaName);
EntityCollection entityCollection = GetEntityDublicates(schemaName, duplicateRecordIds);
Entity goldenEntity = entityCollection.FirstOrDefault();
if (goldenEntity == null)
{
return(response);
}
entityCollection.RemoveFirst();
List <string> resolvedColumns = new List <string>();
if (resolvedConflicts != null)
{
resolvedColumns = resolvedConflicts.Keys.ToList();
}
List <string> conflictColumns = new List <string>();
foreach (EntitySchemaColumn column in goldenEntity.Schema.Columns)
{
if (IsColumnInIgnoreList(column.Name))
{
continue;
}
if (GetIsSystemColumn(entitySchema, column))
{
continue;
}
if (resolvedColumns.Contains(column.Name))
{
continue;
}
bool isConflictColumn = false;
EntityColumnValue goldenColumnValue = goldenEntity.FindEntityColumnValue(column.ColumnValueName);
foreach (Entity entity in entityCollection)
{
EntityColumnValue columnValue = entity.FindEntityColumnValue(column.ColumnValueName);
if (DataTypeUtilities.ValueIsNullOrEmpty(goldenColumnValue.Value))
{
goldenColumnValue = columnValue;
continue;
}
if (DataTypeUtilities.ValueIsNullOrEmpty(columnValue.Value))
{
continue;
}
if (IsEquals(goldenColumnValue.Value, columnValue.Value) == false)
{
isConflictColumn = true;
break;
}
}
if (isConflictColumn)
{
conflictColumns.Add(column.Name);
}
}
if (conflictColumns.Any())
{
conflictColumns.AddRange(resolvedColumns);
EntityCollection conflicts = GetEntityDublicates(schemaName, duplicateRecordIds, conflictColumns);
Dictionary <string, string> columnMap = GetQueryColumns(conflicts.Schema.Columns);
DataContract.EntityCollection convertedEntities =
QueryExtension.GetEntityCollection(conflicts, columnMap);
response.Conflicts = convertedEntities;
}
return(response);
}
private string SetColumnsFromFormFieldsData(FormFieldsData[] formFieldsData, Entity entity)
{
string resultMessage = string.Empty;
if (formFieldsData != null)
{
foreach (FormFieldsData formField in formFieldsData)
{
KeyValuePair <string, string> columnNameValue
= NameValueCorrector.GetCorrectNameValue(formField.name, formField.value);
string columnName = columnNameValue.Key;
string columnValue = columnNameValue.Value;
if (string.IsNullOrEmpty(columnValue))
{
continue;
}
EntitySchemaColumn column = entity.Schema.Columns.GetByName(columnName);
Type columnType = column.DataValueType.ValueType;
if (column.IsLookupType)
{
SetLookupColumn(column, columnValue, entity);
}
else
{
try {
if (WebFormHelper.IsGeographicalColumn(columnName))
{
KeyValuePair <string, string> geogColumn =
WebFormHelper.GetGeographicalUnitColumn(columnName, columnValue, UserConnection);
entity.SetColumnValue(geogColumn.Key, geogColumn.Value);
}
else
{
object value = DataTypeUtilities.ValueAsType(columnValue, columnType);
entity.SetColumnValue(column, value);
}
} catch (Exception ex) {
resultMessage += Environment.NewLine;
string errorMessage;
if (ex is FormatException)
{
errorMessage = GeneratedWebFormLczUtilities.GetLczStringValue(
"FormatExceptionMessage", "GeneratedWebFormService", UserConnection);
}
else if (ex is OverflowException)
{
errorMessage = GeneratedWebFormLczUtilities.GetLczStringValue(
"OverflowExceptionMessage", "GeneratedWebFormService", UserConnection);
}
else
{
errorMessage = GeneratedWebFormLczUtilities.GetLczStringValue(
"ConversionExceptionMessage", "GeneratedWebFormService", UserConnection);
}
resultMessage += string.Format(errorMessage, formField.value, columnType);
}
}
}
}
return(resultMessage);
}
