public object addRecord(GenericFormModel form)
{
DateTime today = DateTime.Today;
try
{
using (DemoEntities db = new DemoEntities())
{
// Read the form data.
GenericTable addRecordForm = new GenericTable();
addRecordForm.Text = form.Text;
addRecordForm.Number = int.Parse(form.Number);
addRecordForm.Boolean = Boolean.Parse(form.Boolean);
addRecordForm.JSDate = DateTime.Parse(form.JSDate);
//addRecordForm.JSDateTime = DateTime.Parse(form.JSDateTime);
db.GenericTables.Add(addRecordForm);
db.SaveChanges();
return(new { status = StatusCodes.OK.code, msg = "Successfully Added Record To Database" });
}
}
catch (System.Exception e)
{
return(new { status = StatusCodes.NotFound.code, msg = e.InnerException, data = 0 });
}
}
public GenericInputFormWindow(GenericFormModel model)
{
InitializeComponent();
_viewModel = Resources["ViewModel"] as GenericInputFormWindowViewModel;
_viewModel.Initialize(this, model);
Response = WindowResponse.KO;
}
public ActionResult GenericForm(GenericFormModel model)
{
if (ModelState.IsValid)
{
var json = new JavaScriptSerializer().Serialize(model);
//You will need to provide your email address and password to the smtp configuration in the root Web.config
//Email.Send(json);
}
return(View(model));
}
public AddUseCaseEditorParameterCommand(UseCaseEditorControlViewModel vm, ParameterDirection direction)
{
Initialize((input) =>
{
try
{
var requestModel = new GenericFormModel("Add new parameter");
requestModel.AddAttribute(ActionParameterDefinition.TypeValue.String,
Definitions.UseCaseEditorDefinitions.UseCaseModelAttibutes.Type,
"Type",
"Type of the parameter",
DataParameter.GetUseCaseParameterTypesList().ToArray());
requestModel.AddAttribute(
ActionParameterDefinition.TypeValue.String,
Definitions.UseCaseEditorDefinitions.UseCaseModelAttibutes.Name,
"Name",
"Name of the parameter");
requestModel.AddAttribute(ActionParameterDefinition.TypeValue.String,
Definitions.UseCaseEditorDefinitions.UseCaseModelAttibutes.EnumerableType,
"Enumerable type",
"If type=Enumerable, this is the type of the enumerable",
DataParameter.GetUseCaseParameterTypesList().ToArray());
requestModel.AddAttribute(
ActionParameterDefinition.TypeValue.String,
Definitions.UseCaseEditorDefinitions.UseCaseModelAttibutes.DictionaryKeyType,
"Dictionary key type",
"If type=Dictionary, this is the type of the key",
DataParameter.GetUseCaseParameterTypesList().ToArray());
requestModel.AddAttribute(ActionParameterDefinition.TypeValue.String,
Definitions.UseCaseEditorDefinitions.UseCaseModelAttibutes.DictionaryValueType,
"Dictionary value type",
"If type=Dictionary, this is the type of the value",
DataParameter.GetUseCaseParameterTypesList().ToArray());
vm.GenericFormRequestId = Guid.NewGuid();
if (direction == ParameterDirection.Input)
{
vm.CurrentFormInputActionType = UseCaseEditorControlViewModel.ActionType.AddInputParameter;
}
else if (direction == ParameterDirection.Output)
{
vm.CurrentFormInputActionType = UseCaseEditorControlViewModel.ActionType.AddOutputParameter;
}
vm.EventManager.RaiseOnGenericFormInputRequestedEvent(vm.GenericFormRequestId, requestModel);
vm.RaiseCanExecuteCommandChanged();
}
catch (Exception ex)
{
vm.RaiseError(ex.Message);
}
}, data =>
{
return(direction == ParameterDirection.Input ||
(direction == ParameterDirection.Output && vm.UseCase?.OutputParameters.Count == 0));
});
}
public void UpdatedFormModel(GenericFormModel model)
{
foreach (var item in model.Attributes)
{
if (item.DefaultValue != null)
{
UpdateValue(item.Key, item.DefaultValue);
}
}
Attributes = model.Attributes;
}
private void SetModel()
{
if (Entity != null && GenericManager != null)
{
GenericFormModel model = new GenericFormModel(string.Empty);
foreach (var item in Entity.Attributes)
{
var type = GetTypeFromAttribute(item);
var defaultValue = InitialValues != null && InitialValues.ContainsKey(item.LogicalName)
? InitialValues[item.LogicalName]
: null;
var attribute = new GenericFormInputModel()
{
Key = item.LogicalName,
DisplayName = item.DisplayName,
Description = item.Description,
IsMandatory = item.IsMandatory,
DefaultValue = defaultValue,
Type = type,
};
if (type == GenericFormInputModel.TypeValue.EntityReference)
{
var relatedEntity = Relationships.First(k => k.RelatedEntity == Entity.LogicalName && k.RelatedAttribute == attribute.Key);
attribute.EntityReferenceSuggestionHandler =
new EntityReferenceHandler(relatedEntity.MainEntity, GenericManager.RetrieveAllHandler, GenericManager.RetrieveHandler);
}
else if (type == GenericFormInputModel.TypeValue.OptionSet)
{
attribute.OptionSetValueOptions = item.Options.Select(k => new DD.Lab.Wpf.Models.Inputs.OptionSetValue()
{
DisplayName = k.DisplayName,
Value = k.Value
}).ToArray();
}
else if (type == GenericFormInputModel.TypeValue.State)
{
var options = new List <DD.Lab.Wpf.Models.Inputs.OptionSetValue>();
options.Add(new DD.Lab.Wpf.Models.Inputs.OptionSetValue()
{
DisplayName = "Enabled", Value = 1
});
options.Add(new DD.Lab.Wpf.Models.Inputs.OptionSetValue()
{
DisplayName = "Disabled", Value = 0
});
attribute.OptionSetValueOptions = options.ToArray();
}
model.Attributes.Add(attribute);
}
FormModel = model;
}
}
public void Initialize(GenericInputFormWindow view, GenericFormModel model)
{
Model = model ?? throw new ArgumentNullException(nameof(model));
_view = view;
}
public static GenericFormModel ToGenericInputModel(this MethodParameterViewModel parameter, string formDescription, OptionSetValue[] options)
{
var model = new GenericFormModel(formDescription);
model.AddAttribute(
GenericFormInputModel.TypeValue.String,
nameof(MethodParameterViewModel.Name),
nameof(MethodParameterViewModel.Name),
nameof(MethodParameterViewModel.Name),
true,
parameter.Name);
var directionAttr = new GenericFormInputModel()
{
DisplayName = nameof(MethodParameterViewModel.Direction),
Key = nameof(MethodParameterViewModel.Direction),
Description = nameof(MethodParameterViewModel.Direction),
IsMandatory = true,
Type = GenericFormInputModel.TypeValue.OptionSet,
OptionSetValueOptions = new List <OptionSetValue>()
{
{ new OptionSetValue(MethodParameter.ParameterDirection.Input.ToString(), (int)MethodParameter.ParameterDirection.Input) },
{ new OptionSetValue(MethodParameter.ParameterDirection.Output.ToString(), (int)MethodParameter.ParameterDirection.Output) }
}.ToArray(),
DefaultValue = ((int)parameter.Direction) > 0 ? new OptionSetValue((int)parameter.Direction) : null
};
var typeAttr = new GenericFormInputModel()
{
DisplayName = nameof(MethodParameterViewModel.Type),
Key = nameof(MethodParameterViewModel.Type),
Description = nameof(MethodParameterViewModel.Type),
IsMandatory = true,
Type = GenericFormInputModel.TypeValue.OptionSet,
OptionSetValueOptions = options,
DefaultValue = ((int)parameter.Type) > 0 ? new OptionSetValue((int)parameter.Type) : null
};
var enumAttr = new GenericFormInputModel()
{
DisplayName = nameof(MethodParameterViewModel.EnumerableType),
Key = nameof(MethodParameterViewModel.EnumerableType),
Description = nameof(MethodParameterViewModel.EnumerableType),
IsMandatory = false,
Type = GenericFormInputModel.TypeValue.OptionSet,
OptionSetValueOptions = options,
DefaultValue = ((int)parameter.EnumerableType) > 0 ? new OptionSetValue((int)parameter.EnumerableType) : null
};
var dicKeyAttr = new GenericFormInputModel()
{
DisplayName = nameof(MethodParameterViewModel.DictionaryKeyType),
Key = nameof(MethodParameterViewModel.DictionaryKeyType),
Description = nameof(MethodParameterViewModel.DictionaryKeyType),
IsMandatory = false,
Type = GenericFormInputModel.TypeValue.OptionSet,
OptionSetValueOptions = options,
DefaultValue = ((int)parameter.DictionaryKeyType) > 0 ? new OptionSetValue((int)parameter.DictionaryKeyType) : null
};
var dicValueAttr = new GenericFormInputModel()
{
DisplayName = nameof(MethodParameterViewModel.DictionaryValueType),
Key = nameof(MethodParameterViewModel.DictionaryValueType),
Description = nameof(MethodParameterViewModel.DictionaryValueType),
IsMandatory = false,
Type = GenericFormInputModel.TypeValue.OptionSet,
OptionSetValueOptions = options,
DefaultValue = ((int)parameter.DictionaryValueType) > 0 ? new OptionSetValue((int)parameter.DictionaryValueType) : null
};
model.Attributes.Add(directionAttr);
model.Attributes.Add(typeAttr);
model.Attributes.Add(enumAttr);
model.Attributes.Add(dicKeyAttr);
model.Attributes.Add(dicValueAttr);
return(model);
}
public GenericFormRequestEventArgs(Guid requestId, GenericFormModel formModel)
: this(requestId, formModel, new Dictionary <string, object>())
{
}
public GenericFormRequestEventArgs(Guid requestId, GenericFormModel formModel, Dictionary <string, object> initialValues)
{
RequestId = requestId;
FormModel = formModel;
InitialValues = initialValues;
}
public void RaiseOnGenericFormInputRequestedEvent(Guid requestId, GenericFormModel formModel)
{
OnGenericFormInputRequested?.Invoke(this, new GenericFormRequestEventArgs(requestId, formModel));
}
private void SetFormModel(GenericFormModel data)
{
_viewModel.FormModel = data;
}
