public ActionResult ResourceTypeIndex()
{
ResourceTypeModel db = new ResourceTypeModel();
db.ResourceTypeList = _iResourceService.GetResourceTypeList();
return(View(db));
}
private static IReadOnlyList <ResourceTypeModel> FilterTypes(ResourceTypeModel typeNode, string[] constraint)
{
if (constraint.Contains(typeNode.Name))
{
return new[] { typeNode }
}
;
return(typeNode.DerivedTypes.SelectMany(dt => FilterTypes(dt, constraint)).ToArray());
}
public ActionResult CreateEditResourceType(int?resourceTypeId)
{
ResourceTypeModel rtModel = new ResourceTypeModel();
if (resourceTypeId != null)
{
rtModel = _iResourceService.GetResourceTypeList().Where(x => x.ResourceTypeId == resourceTypeId).FirstOrDefault();
}
return(PartialView("_CreateEditResourceType", rtModel));
}
/// <inheritdoc />
public override async Task ConnectionCallback(ConnectionState connectionState)
{
if (connectionState != ConnectionState.Success)
{
TypeTree = new ResourceTypeModel();
}
else
{
await GetTypeTree();
}
}
public ActionResult CreateEditResourceType(ResourceTypeModel rtModel)
{
if (ModelState.IsValid)
{
var result = _iResourceService.CreateEditResourceType(rtModel);
return(Json(result, JsonRequestBehavior.AllowGet));
}
else
{
return(Json(rModel, JsonRequestBehavior.AllowGet));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ResourceTypeViewModel"/> class.
/// </summary>
public ResourceTypeViewModel(ResourceTypeModel model)
{
_model = model;
Constructors = model.Constructors.Select(c => new ConstructorViewModel(c)).ToArray();
if (Constructors.Length > 0)
{
Constructors[0].IsSelected = true;
}
DerivedTypes = model.DerivedTypes.Select(d => new ResourceTypeViewModel(d)).ToArray();
References = model.References.Select(r => new ReferenceTypeViewModel(this, r)).ToArray();
}
protected override void ClientCallback(ConnectionState state, ResourceInteractionClient client)
{
base.ClientCallback(state, client);
if (state != ConnectionState.Success)
{
TypeTree = new ResourceTypeModel();
}
if (IsAvailable)
{
Task.Run(async delegate
{
await GetTypeTree();
});
}
}
public ReturnMessageModel CreateEditResourceType(ResourceTypeModel rtModel)
{
try
{
using (PointOfSaleEntities _context = new PointOfSaleEntities())
{
var rtRow = _context.ResourceTypes.Where(x => x.ResourceTypeId == rtModel.ResourceTypeId).FirstOrDefault();
if (rtRow == null)
{
rtRow = new ResourceType();
}
rtRow.ResourceTypeName = rtModel.ResourceTypeName;
rtRow.ResourceTypeCode = rtModel.ResourceTypeCode;
rtRow.IsActive = rtModel.IsActive;
if (rtModel.ResourceTypeId == 0)
{
rtRow.CreatedBy = WebSecurity.CurrentUserId;
rtRow.CreatedDate = System.DateTime.Now;
_context.ResourceTypes.Add(rtRow);
_context.SaveChanges();
}
else
{
rtRow.ModifiedBy = WebSecurity.CurrentUserId;
rtRow.ModifiedDate = System.DateTime.Now;
_context.ResourceTypes.Attach(rtRow);
_context.Entry(rtRow).State = EntityState.Modified;
_context.SaveChanges();
}
rModel.Msg = "Resource Type Saved Successfully";
rModel.Success = true;
return(rModel);
}
}
catch (Exception ex)
{
rModel.Msg = "Resource Type Saved Failed";
rModel.Success = false;
return(rModel);
}
}
private static ResourceTypeModel FindType(string searchedType, ResourceTypeModel typeBranch)
{
if (typeBranch.Name == searchedType)
{
return(typeBranch);
}
foreach (var typeModel in typeBranch.DerivedTypes)
{
var match = FindType(searchedType, typeModel);
if (match != null)
{
return(match);
}
}
return(null);
}
/// <summary>
/// Convert <see cref="IResourceTypeNode"/> to <see cref="ResourceTypeModel"/> without converting a type twice
/// </summary>
internal ResourceTypeModel ConvertType(IResourceTypeNode node, ResourceTypeModel baseType)
{
var resType = node.ResourceType;
if (TypeCache.ContainsKey(node.Name))
{
return(TypeCache[node.Name]);
}
// Remove generic arguments from type name
var typeModel = new ResourceTypeModel
{
Creatable = node.Creatable,
Name = node.Name,
BaseType = baseType?.Name,
// Read display name of the type otherwise use type short name
DisplayName = resType.GetCustomAttribute <DisplayNameAttribute>(false)?.DisplayName ??
Regex.Replace(resType.Name, @"`\d", string.Empty),
// Read description of the type
Description = resType.GetCustomAttribute <DescriptionAttribute>(false)?.Description,
// Convert resource constructors
Constructors = node.Constructors.Select(ctr => EntryConvert.EncodeMethod(ctr, Serialization)).ToArray()
};
// Convert reference properties
var properties = node.ResourceType.GetProperties();
var references = GetReferences(properties);
var overrides = GetReferenceOverrides(properties);
typeModel.References = references.Select(reference => ConvertReferenceProperty(reference, overrides)).ToArray();
typeModel.DerivedTypes = node.DerivedTypes.Select(t => ConvertType(t, typeModel)).ToArray();
TypeCache[node.Name] = typeModel;
return(typeModel);
}
public void post_name(ResourceTypeModel input)
{
}
public void post_name(ResourceTypeModel input)
{
}
/// <inheritdoc />
public async Task <ResourceTypeModel> GetTypeTree()
{
TypeTree = await GetAsync <ResourceTypeModel>("types");
return(TypeTree);
}
public async Task <ResourceTypeModel> GetTypeTree()
{
TypeTree = await WcfClient.GetTypeTreeAsync();
return(TypeTree);
}
public ResourceServiceModel(IWcfClientFactory clientFactory)
{
ClientFactory = clientFactory;
TypeTree = new ResourceTypeModel();
}
