private void EditSelect(FieldViewModel fieldViewModel)
{
FieldEdit fieldEdit = new FieldEdit();
fieldEdit.DataContext = fieldViewModel;
fieldEdit.Show();
}
/// <summary>
/// The create field vm.
/// </summary>
/// <param name="field">The field.</param>
/// <param name="parentSection">The parent section.</param>
/// <returns>The <see cref="ProcessFieldViewModel" />.</returns>
public ProcessFieldViewModel CreateFieldVM(FieldEdit field, ProcessSectionViewModel parentSection)
{
var fieldVm = new ProcessFieldViewModel(field, parentSection);
//DeploymentService.Container.ComposeParts(fieldVM);
DeploymentService.Container.SatisfyImportsOnce(fieldVm);
return fieldVm;
}
/// <summary>
/// Initializes a new instance of the <see cref="FieldEditMemberDefinition"/> class.
/// </summary>
/// <param name="field">
/// The field.
/// </param>
public FieldEditMemberDefinition(FieldEdit field)
{
if (field == null)
throw new ArgumentNullException("field");
_field = field;
}
public IFeatureClass CreateFeatureClass(string string_0, esriGeometryType esriGeometryType_0,
ISpatialReference ispatialReference_0, bool bool_0, bool bool_1, int int_0)
{
IFeatureWorkspace mWorkspace = (IFeatureWorkspace)this.m_Workspace;
IFieldsEdit fieldsClass = (IFieldsEdit)(new Fields() as IFieldsEdit);
FieldEdit.AddDefaultField(fieldsClass, esriGeometryType_0, ispatialReference_0, bool_0, bool_1, int_0);
IFeatureClass featureClass = mWorkspace.CreateFeatureClass(string_0, fieldsClass, null, null,
esriFeatureType.esriFTSimple, "Shape", "");
return(featureClass);
}
/// <summary>
/// Initializes the specified model.
/// </summary>
/// <param name="model">The model.</param>
/// <param name="processEdit">The process edit.</param>
/// <param name="fieldEdit">The field edit.</param>
public void Init(ChecklistSettingsStepEdit model, ProcessEdit processEdit, FieldEdit fieldEdit)
{
StepModel = model;
ProcessEdit = processEdit;
FieldEdit = fieldEdit;
FilterGuid = model.FilterGuid ?? Guid.Empty;
FilterDefinition = model.FilterDefinition;
var weakListener = new WeakEventListener<ChecklistFilterViewModel, ChecklistSettingsStepEdit, PropertyChangedEventArgs>(this, model);
model.PropertyChanged += weakListener.OnEvent;
weakListener.OnEventAction += OnReqStepPropertyChanged;
weakListener.OnDetachAction += Static;
LoadProcessInfo(model);
}
/// <summary>
/// Adds the field.
/// </summary>
/// <param name="sectionId">The section identifier.</param>
/// <param name="parentModel">The parent model.</param>
/// <param name="f">The f.</param>
public void AddField(int sectionId, BusinessBase parentModel, FieldEdit f)
{
foreach (var step in f.StepList)
{
step.AddProps();
}
var expandableObj = new ExpandableStepPropBag(parentModel) { FieldSecurityManager = ProcessScreenSecuritySettings, Model = f };
foreach (var step in f.StepList)
{
step.UpdateProps(expandableObj);
}
expandableObj.PreviewMode = true;
//if (expandableObj.SectionId == sectionId)
{
Fields.Add(expandableObj);
FieldList.Add(f);
}
}
/// <summary>
/// Creates the generic source field.
/// </summary>
/// <param name="field">The field.</param>
/// <param name="owner">The owner.</param>
/// <returns>SourceField.</returns>
private static SourceField CreateGenericSourceField(FieldEdit field, ExpressionObjectBase owner)
{
var dataType = SourceNodeFactory.GetDataType(GetType(field));
var sf = new SourceField(owner)
{
DataType = dataType,
Name = field.Name,
ConnectorOut = { DataType = dataType, Name = field.Name },
SetName = SourceFieldSetNames.DataTriggerSourceItem,
InnerName = field.SystemName,
SystemName = field.SystemName
};
return sf;
}
/// <summary>
/// Determines whether [is email field] [the specified field].
/// </summary>
/// <param name="field">The field.</param>
/// <returns><c>true</c> if [is email field] [the specified field]; otherwise, <c>false</c>.</returns>
private static bool IsEmailField(FieldEdit field)
{
return field.FieldType != null && field.FieldType.ColumnType == ColumnTypes.String;
}
/// <summary>
/// Determines whether [is role field] [the specified field].
/// </summary>
/// <param name="field">The field.</param>
/// <returns><c>true</c> if [is role field] [the specified field]; otherwise, <c>false</c>.</returns>
private static bool IsRoleField(FieldEdit field)
{
if (field.FieldType == null)
return false;
if (field.FieldType.ColumnType == ColumnTypes.Reference ||
field.FieldType.ColumnType == ColumnTypes.MultiReference)
{
var crStep = field.StepList.OfType<CrossRefRequiredStepEdit>().FirstOrDefault();
return crStep != null && crStep.CrossRefProcess != null && crStep.CrossRefProcess.IsA(Constants.BaseRoleProcessName);
}
return false;
}
/// <summary>
/// Builds the source field for list.
/// </summary>
/// <param name="source">The source.</param>
/// <param name="field">The field.</param>
/// <param name="subfieldsRetriever">The subfields retriever.</param>
/// <returns> Source Field. </returns>
private static SourceField BuildSourceFieldForList(SourceFieldList source, FieldEdit field, IExpressionFieldsRetriever subfieldsRetriever)
{
return new SourceField(source)
{
DataType = NodeDataType.List,
Name = field.Name,
ConnectorOut = {DataType = NodeDataType.List, Name = field.Name},
SetName = SourceFieldSetNames.Item,
InnerName = string.Format("{0}List", field.SystemName),
SystemName = string.Format("{0}List", field.SystemName),
SubfieldsRetriever = subfieldsRetriever
};
}
/// <summary>
/// Determines whether the specified field is calculated.
/// </summary>
/// <param name="field">The field.</param>
/// <returns><c>true</c> if the specified field is calculated; otherwise, <c>false</c>.</returns>
private static bool IsCalculated(FieldEdit field)
{
var expressionsStep =
field.StepList.FirstOrDefault(step => step is ExpressionsStepEdit) as ExpressionsStepEdit;
if (expressionsStep == null)
return false;
return !string.IsNullOrEmpty(expressionsStep.CalculatedExpression);
}
/// <summary>
/// Creates the cross reference destination field.
/// </summary>
/// <param name="field">The field.</param>
/// <param name="owner">The owner.</param>
/// <returns>DestinationField.</returns>
private static DestinationField CreateCrossReferenceDestinationField(FieldEdit field, ExpressionObjectBase owner)
{
var isSingleRef = field.IsSingleCrossReference();
var df = new DestinationField(owner)
{
DataType = NodeDataType.CrossReference,
Name = field.Name,
ConnectorIn = { DataType = NodeDataType.CrossReference, Name = field.Name },
SystemName = field.SystemName,
SetName = SourceFieldSetNames.Item,
IsKeyVisible = true,
IsKeyEnabled = isSingleRef,
SubfieldsRetriever = new CrossReferenceSubfieldsRetriever(field)
};
return df;
}
/// <summary>
/// Creates the destination field.
/// </summary>
/// <param name="field">The field.</param>
/// <param name="owner">The owner.</param>
/// <returns>DestinationField.</returns>
private static DestinationField CreateDestinationField(FieldEdit field, ExpressionObjectBase owner)
{
var columnType = GetColumnType(field);
switch (columnType)
{
case ColumnTypes.Reference:
case ColumnTypes.MultiReference:
return CreateCrossReferenceDestinationField(field, owner);
case ColumnTypes.File:
return CreateFileDestinationField(field, owner);
case ColumnTypes.Integer:
case ColumnTypes.String:
case ColumnTypes.Numeric:
case ColumnTypes.Boolean:
case ColumnTypes.DateTime:
return CreateGenericDestinationField(field, owner);
}
return null;
}
/// <summary>
/// Determines whether this instance [can be key field] the specified field.
/// </summary>
/// <param name="field">The field.</param>
/// <returns><c>true</c> if this instance [can be key field] the specified field; otherwise, <c>false</c>.</returns>
private static bool CanBeKeyField(FieldEdit field)
{
if (!CanBeDestinationField(field))
return false;
switch (GetColumnType(field))
{
case ColumnTypes.Integer:
case ColumnTypes.String:
case ColumnTypes.Reference:
case ColumnTypes.Numeric:
case ColumnTypes.Boolean:
case ColumnTypes.DateTime:
return true;
}
return false;
}
/// <summary>
/// Includes the field.
/// </summary>
/// <param name="field">The field.</param>
/// <returns><c>true</c> if XXXX, <c>false</c> otherwise.</returns>
private static bool IncludeField(FieldEdit field)
{
switch (field.FieldType.ColumnType)
{
case ColumnTypes.Integer:
return true;
case ColumnTypes.String:
return true;
case ColumnTypes.Numeric:
return true;
case ColumnTypes.Boolean:
return true;
case ColumnTypes.DateTime:
return true;
}
return false;
}
/// <summary>
/// Creates the source field.
/// </summary>
/// <param name="field">The field.</param>
/// <param name="owner">The owner.</param>
/// <returns>SourceField.</returns>
/// <exception cref="System.ArgumentException">Field type not supported.;field</exception>
private static SourceField CreateSourceField(FieldEdit field, ExpressionObjectBase owner)
{
switch (field.FieldType.ColumnType)
{
case ColumnTypes.Integer:
case ColumnTypes.String:
case ColumnTypes.Numeric:
case ColumnTypes.Double:
case ColumnTypes.Boolean:
case ColumnTypes.DateTime:
case ColumnTypes.AutoNumber:
case ColumnTypes.SampleType:
case ColumnTypes.Sample:
case ColumnTypes.Label:
return CreateGenericSourceField(field, owner);
case ColumnTypes.Reference:
case ColumnTypes.MultiReference:
return CreateCrossReferenceSourceField(field, owner);
case ColumnTypes.File:
return CreateFileSourceField(field, owner);
default:
throw new ArgumentException("Field type not supported.", "field");
}
}
/// <summary>
/// Determines whether this instance [can be source field] the specified field.
/// </summary>
/// <param name="field">The field.</param>
/// <returns><c>true</c> if this instance [can be source field] the specified field; otherwise, <c>false</c>.</returns>
private static bool CanBeSourceField(FieldEdit field)
{
switch (field.FieldType.ColumnType)
{
case ColumnTypes.Integer:
case ColumnTypes.String:
case ColumnTypes.Reference:
case ColumnTypes.MultiReference:
case ColumnTypes.Numeric:
case ColumnTypes.Double:
case ColumnTypes.Boolean:
case ColumnTypes.DateTime:
case ColumnTypes.AutoNumber:
case ColumnTypes.SampleType:
case ColumnTypes.Label:
case ColumnTypes.File:
case ColumnTypes.Sample:
return true;
default:
return false;
}
}
public IndexPage(IWebDriver driverValue) : base(driverValue)
{
FeelingLuckyButton = new Controller(this, By.XPath("//*/center/input[2]"));
SearchButton = new Controller(this, By.XPath("//*/center/input[1]"));
SearchField = new FieldEdit(this, By.Name("q"));
}
/// <summary>
/// Determines whether this instance [can be destination field] the specified field.
/// </summary>
/// <param name="field">The field.</param>
/// <returns><c>true</c> if this instance [can be destination field] the specified field; otherwise, <c>false</c>.</returns>
private static bool CanBeDestinationField(FieldEdit field)
{
if (field.IsDeleted || IsCalculated(field))
return false;
switch (GetColumnType(field))
{
case ColumnTypes.Integer:
case ColumnTypes.String:
case ColumnTypes.Reference:
case ColumnTypes.MultiReference:
case ColumnTypes.Numeric:
case ColumnTypes.Boolean:
case ColumnTypes.DateTime:
case ColumnTypes.File:
return true;
}
return false;
}
/// <summary>
/// Creates the cross reference source field.
/// </summary>
/// <param name="field">The field.</param>
/// <param name="owner">The owner.</param>
/// <returns>SourceField.</returns>
private static SourceField CreateCrossReferenceSourceField(FieldEdit field, ExpressionObjectBase owner)
{
var dataType = field.IsSingleCrossReference()
? NodeDataType.CrossReference
: NodeDataType.List;
var requiredStep = (CrossRefRequiredStepEdit)field.StepList.FirstOrDefault(s => s is CrossRefRequiredStepEdit);
IExpressionFieldsRetriever subfieldsRetriever = null;
if (requiredStep != null && requiredStep.CrossRefProcessId.HasValue)
{
subfieldsRetriever = new CrossReferenceSubfieldsRetriever(requiredStep.CrossRefProcessId.Value, CanBeSourceField, CreateSourceField);
}
var sf = new SourceField(owner)
{
DataType = dataType,
Name = field.Name,
ConnectorOut = { DataType = dataType, Name = field.Name },
SystemName = field.SystemName,
SetName = SourceFieldSetNames.DataTriggerSourceItem,
SubfieldsRetriever = subfieldsRetriever
};
return sf;
}
/// <summary>
/// Gets the type of the column.
/// </summary>
/// <param name="field">The field.</param>
/// <returns>ColumnTypes.</returns>
/// <exception cref="System.ArgumentException">Field does not have a type.</exception>
private static ColumnTypes GetColumnType(FieldEdit field)
{
if (field.FieldType == null)
throw new ArgumentException("Field does not have a type.");
var columnType = field.FieldType.ColumnType;
var result = columnType;
if (columnType == ColumnTypes.Reference)
{
var requiredStep = field.StepList.OfType<CrossRefRequiredStepEdit>().First();
if (requiredStep.AllowMultiple)
result = ColumnTypes.MultiReference;
}
if (columnType == ColumnTypes.ReverseReference)
{
var requiredStep = field.StepList.OfType<ReverseCrossRefRequiredStepEdit>().First();
if (requiredStep.DisplayMultiple)
result = ColumnTypes.ReverseMultiReference;
}
return result;
}
/// <summary>
/// Creates the file source field.
/// </summary>
/// <param name="field">The field.</param>
/// <param name="owner">The owner.</param>
/// <returns>SourceField.</returns>
private static SourceField CreateFileSourceField(FieldEdit field, ExpressionObjectBase owner)
{
const NodeDataType DataType = NodeDataType.File;
var sf = new SourceField(owner)
{
DataType = DataType,
Name = field.Name,
ConnectorOut = { DataType = DataType, Name = field.Name },
SystemName = field.SystemName,
SetName = SourceFieldSetNames.DataTriggerSourceItem,
SubfieldsRetriever = new FileSubfieldsRetriever(SourceFieldSetNames.DataTriggerSourceItem)
};
return sf;
}
/// <summary>
/// Creates the generic destination field.
/// </summary>
/// <param name="field">The field.</param>
/// <param name="owner">The owner.</param>
/// <returns>DestinationField.</returns>
private static DestinationField CreateGenericDestinationField(FieldEdit field, ExpressionObjectBase owner)
{
var dataType = DestinationNodeFactory.GetDataType(GetType(field));
var df = new DestinationField(owner)
{
DataType = dataType,
Name = field.Name,
IsKeyVisible = true,
IsKeyEnabled = CanBeKeyField(field),
ConnectorIn = { DataType = dataType, Name = field.Name },
SystemName = field.SystemName,
SetName = SourceFieldSetNames.Item
};
return df;
}
/// <summary>
/// Determines whether this instance [can be destination field] the specified field.
/// </summary>
/// <param name="field">The field.</param>
/// <returns><c>true</c> if this instance [can be destination field] the specified field; otherwise, <c>false</c>.</returns>
private static bool CanBeDestinationField(FieldEdit field)
{
switch (field.ColumnType)
{
case ColumnTypes.Integer:
case ColumnTypes.String:
case ColumnTypes.Numeric:
case ColumnTypes.Double:
case ColumnTypes.Boolean:
case ColumnTypes.DateTime:
case ColumnTypes.SampleType:
case ColumnTypes.Reference:
case ColumnTypes.Result:
case ColumnTypes.Sample:
case ColumnTypes.Checklist:
return true;
default:
return false;
}
}
/// <summary>
/// Creates the file destination field.
/// </summary>
/// <param name="field">The field.</param>
/// <param name="owner">The owner.</param>
/// <returns>DestinationField.</returns>
private static DestinationField CreateFileDestinationField(FieldEdit field, ExpressionObjectBase owner)
{
var dataType = DestinationNodeFactory.GetDataType(typeof(string));
var df = new DestinationField(owner)
{
DataType = dataType,
Name = field.Name,
ConnectorIn = { DataType = dataType, Name = field.Name },
SystemName = field.SystemName,
SetName = SourceFieldSetNames.Item,
IsKeyVisible = true,
IsKeyEnabled = false
};
return df;
}
/// <summary>
/// Creates the destination field.
/// </summary>
/// <param name="field">The field.</param>
/// <param name="owner">The owner.</param>
/// <returns>DestinationField.</returns>
/// <exception cref="System.InvalidOperationException">Destination field should be writeable.</exception>
/// <exception cref="System.ArgumentException">Field type not supported.;field</exception>
private DestinationField CreateDestinationField(FieldEdit field, ExpressionObjectBase owner)
{
switch (field.ColumnType)
{
case ColumnTypes.Integer:
case ColumnTypes.String:
case ColumnTypes.Numeric:
case ColumnTypes.Double:
case ColumnTypes.Boolean:
case ColumnTypes.DateTime:
case ColumnTypes.SampleType:
case ColumnTypes.Reference:
case ColumnTypes.Result:
case ColumnTypes.Sample:
case ColumnTypes.Checklist:
{
var dataType = GetDataType(field);
var df = new DestinationField(owner)
{
DataType = dataType,
Name = field.Name,
ConnectorIn = { DataType = dataType, Name = field.Name },
SetName = SourceFieldSetNames.DataTriggerDestinationItem,
InnerName = field.SystemName,
SystemName = field.SystemName,
SubfieldsRetriever = GetDestinationFieldsRetriever(field)
};
return df;
}
default:
throw new ArgumentException("Field type not supported.", "field");
}
}
/// <summary>
/// Gets the type.
/// </summary>
/// <param name="field">The field.</param>
/// <returns>Type.</returns>
static Type GetType(FieldEdit field)
{
if (field.FieldType.ColumnType == ColumnTypes.Numeric)
{
var step = field.StepList.FirstOrDefault(s => s.GetType() == typeof(NumericRequiredStepEdit)) as NumericRequiredStepEdit;
if (step != null)
return GetType(step.GetColumnType());
}
return GetType(field.FieldType);
}
private IExpressionFieldsRetriever GetDestinationFieldsRetriever(FieldEdit field)
{
switch (field.ColumnType)
{
case ColumnTypes.Checklist:
{
var settingsStep = field.GetStep<ChecklistSettingsStepEdit>();
if (settingsStep == null || string.IsNullOrEmpty(settingsStep.AnswerProcessSystemName))
{
return null;
}
return new ChecklistSubfieldsRetriever(
settingsStep.AnswerProcessSystemName,
f => f.SystemName != Constants.IdColumnName && CanBeDestinationField(f) && f.ColumnType != ColumnTypes.Checklist,
CreateDestinationField);
}
default:
return null;
}
}
public JsonResult FieldSave(FieldEdit model = null)
{
var result = JsonAnswer();
try
{
using (var db = this.CreateUnitOfWork())
{
if (model.IdModule <= 0)
{
throw new Exception("Не указан идентификатор модуля.");
}
var module = AppCore.GetModulesManager().GetModule(model.IdModule) as IModuleCore;
if (module == null)
{
throw new Exception("Модуль не найден.");
}
CustomFieldsField data = null;
if (model.IdField > 0)
{
data = db.CustomFieldsFields.Where(x => x.IdField == model.IdField).Include(x => x.data).FirstOrDefault();
if (data == null)
{
throw new Exception("Такое поле не найдено в базе данных!");
}
if (data.IdModule != model.IdModule)
{
var module2 = AppCore.GetModulesManager().GetModule(data.IdModule);
if (module2 == null)
{
throw new Exception("Это поле относится к другому модулю.");
}
else
{
throw new Exception(string.Format("Это поле относится к модулю '{0}'.", module2.Caption));
}
}
}
else
{
data = new CustomFieldsField()
{
IdFieldType = 0, IdModule = model.IdModule
};
db.CustomFieldsFields.Add(data);
}
if (ModelState.ContainsKeyCorrect(nameof(model.name)))
{
data.name = model.name;
}
if (ModelState.ContainsKeyCorrect(nameof(model.nameAlt)))
{
data.nameAlt = model.nameAlt;
}
if (ModelState.ContainsKeyCorrect(nameof(model.alias)))
{
data.alias = model.alias;
}
if (ModelState.ContainsKeyCorrect(nameof(model.formatCheck)))
{
data.formatCheck = model.formatCheck;
}
if (ModelState.ContainsKeyCorrect(nameof(model.IdFieldType)))
{
data.IdFieldType = model.IdFieldType;
}
if (ModelState.ContainsKeyCorrect(nameof(model.IsValueRequired)))
{
data.IsValueRequired = model.IsValueRequired;
}
if (ModelState.ContainsKeyCorrect(nameof(model.IdValueType)))
{
data.IdValueType = model.IdValueType;
}
if (ModelState.ContainsKeyCorrect(nameof(model.size)))
{
data.size = model.size;
}
if (ModelState.ContainsKeyCorrect(nameof(model.nameEnding)))
{
data.nameEnding = model.nameEnding;
}
using (var scope = db.CreateScope())
{
var entry = db.GetState(data);
if (entry == ItemState.Detached)
{
throw new Exception("Невозможно найти поле для сохранения.");
}
else if (entry.In(ItemState.Modified, ItemState.Added))
{
data.DateChange = DateTime.Now.Timestamp();
data.Block = 0;
if (db.SaveChanges <CustomFieldsField>() == 0)
{
throw new Exception("Сохранение поля провалилось!");
}
}
if (Request.Form.HasKey("values"))
{
var t = DateTime.Now.Timestamp();
var vals = Request.Form.TryGetValue <CustomFieldsValue[]>("values");
if (vals != null)
{
foreach (var d in vals)
{
d.IdField = data.IdField;
//d.Field = data;
d.DateChange = t;
}
db.CustomFieldsValues.AddOrUpdate(vals);
}
else
{
vals = new CustomFieldsValue[0];
}
var values = vals.ToList();
if (values.Count > 0)
{
if (db.SaveChanges <CustomFieldsValue>() == 0)
{
throw new Exception("Не удалось сохранить варианты значений поля");
}
}
data.data = data.FieldType.CreateValuesCollection(data, values);
var keys = values.Select(x => x.IdFieldValue);
var removeExistsValue = new Dictionary <int, string>();
var removeExistsObjects = new Dictionary <int, List <int> >();
var sql = (from p in db.CustomFieldsValues
join d in db.CustomFieldsDatas on p.IdFieldValue equals d.IdFieldValue
where p.IdField == data.IdField && !keys.Contains(p.IdFieldValue)
select new { p, d });
foreach (var res in sql)
{
removeExistsValue[res.p.IdFieldValue] = res.p.FieldValue;
if (!removeExistsObjects.ContainsKey(res.p.IdFieldValue))
{
removeExistsObjects[res.p.IdFieldValue] = new List <int>();
}
if (!removeExistsObjects[res.p.IdFieldValue].Contains(res.d.IdItem))
{
removeExistsObjects[res.p.IdFieldValue].Add(res.d.IdItem);
}
}
if (removeExistsValue.Count > 0)
{
var removeTexts = new Dictionary <int, string>();
foreach (var pair in removeExistsValue)
{
removeTexts[pair.Key] = " - №" + pair.Key + " \"" + pair.Value + "\" у объектов №" + string.Join(", №", removeExistsObjects[pair.Key]);
}
throw new Exception("Некоторые значения, которые вы пытаетесь удалить, указаны у следующих объектов:\r\n" + string.Join(", \r\n", removeTexts.Values));
}
//todo подозрение, что неправильный запрос, может очистить всю таблицу.
//DB.CustomFieldsValues.Where(x => !keys.Contains(x.IdFieldValue)).Delete();
}
result.Message = "Сохранение поля прошло успешно!";
result.Success = true;
result.Data = data;
scope.Commit();
}
result.Success = true;
}
}
catch (OnUtils.Data.Validation.EntityValidationException ex) { result.Message = ex.CreateComplexMessage(); }
catch (Exception ex) { result.Message = ex.Message; }
return(ReturnJson(result));
}
/// <summary>
/// Gets the type.
/// </summary>
/// <param name="field">The field.</param>
/// <returns>Type.</returns>
/// <exception cref="System.ArgumentException">
/// Cross reference required step not found.;field
/// or
/// Field type not supported.;field
/// </exception>
private static Type GetType(FieldEdit field)
{
var columnType = field.ColumnType;
return columnType != null ? GetType(columnType.Value) : typeof(string);
}
/// <summary>
/// Determines whether [is approval field] [the specified field].
/// </summary>
/// <param name="field">The field.</param>
/// <returns><c>true</c> if [is approval field] [the specified field]; otherwise, <c>false</c>.</returns>
private static bool IsApprovalField(FieldEdit field)
{
return field.FieldType != null && field.FieldType.ColumnType == ColumnTypes.Approval;
}
private static NodeDataType GetDataType(FieldEdit field)
{
var columnType = field.ColumnType;
return columnType != null ? GetDataType(columnType.Value) : NodeDataType.String;
}
/// <summary>
/// Determines whether [is date field] [the specified field].
/// </summary>
/// <param name="field">The field.</param>
/// <returns><c>true</c> if [is date field] [the specified field]; otherwise, <c>false</c>.</returns>
private static bool IsDateField(FieldEdit field)
{
return field.FieldType != null && field.FieldType.ColumnType == ColumnTypes.DateTime;
}
/// <summary>
/// Initializes a new instance of the <see cref="CrossReferenceSubfieldsRetriever"/> class.
/// </summary>
/// <param name="field">The field.</param>
/// <exception cref="System.ArgumentNullException">field</exception>
/// <exception cref="System.ArgumentException">
/// Field is not a cross reference.
/// or
/// Cross reference process is null.
/// </exception>
public CrossReferenceSubfieldsRetriever(FieldEdit field)
{
if (field == null) throw new ArgumentNullException("field");
var crStep = (CrossRefRequiredStepEdit)field.StepList.FirstOrDefault(step => step.GetType() == typeof (CrossRefRequiredStepEdit));
if (crStep == null)
throw new ArgumentException("Field is not a cross reference.");
if (!crStep.CrossRefProcessId.HasValue)
throw new ArgumentException("Cross reference process is null.");
_crossRefProcessId = crStep.CrossRefProcessId.Value;
}
