public void AddMethod(SiteDb siteDb, IDataMethodSetting dataMethod, bool isGlobal)
{
var typeInfo = DataSourceHelper.GetFields(siteDb, dataMethod);
DataMethodViewModel model = new DataMethodViewModel
{
Id = dataMethod.Id,
IsGlobal = isGlobal,
DisplayName = dataMethod.DisplayName,
Parameters = dataMethod.Parameters,
MethodName = dataMethod.MethodName,
OriginalMethodName = dataMethod.OriginalMethodName,
TotalRelations = 10,
MethodSignatureHash = dataMethod.MethodSignatureHash,
Description = dataMethod.Description,
DeclareType = dataMethod.DeclareType,
IsNew = dataMethod.Id == Guid.Empty,
IsPublic = dataMethod.IsPublic,
ReturnType = dataMethod.ReturnType,
IsPagedResult = dataMethod.IsPagedResult,
IsConfigurable = dataMethod.Parameters.Any(),
ItemFields = typeInfo.ItemFields,
Enumerable = typeInfo.Enumerable
};
if (!dataMethod.IsPublic && !isGlobal)
{
var viewdatamethod = siteDb.ViewDataMethods.Query.Where(o => o.MethodId == dataMethod.Id).SelectAll();
foreach (var item in viewdatamethod)
{
if (item.ViewId != default(Guid))
{
var view = siteDb.Views.Get(item.ViewId, true);
if (view != null)
{
model.ViewId = view.Id;
model.ViewName = view.Name;
}
break;
}
}
}
if (model.IsGlobal && model.Parameters.Any())
{
model.IsConfigurable = true;
}
Methods.Add(model);
}
public static DataMethodCompiled GetGlobalCompiledMethod(Guid MethodId)
{
lock (_lock)
{
DataMethodCompiled compiled;
if (MethodCache.TryGetValue(MethodId, out compiled))
{
return(compiled);
}
IDataMethodSetting DataMethod = Data.GlobalDb.DataMethodSettings.Get(MethodId);
compiled = new DataMethodCompiled(DataMethod);
MethodCache[MethodId] = compiled;
return(compiled);
}
}
public static List <Guid> GetFolderIds(IDataMethodSetting methodsetting)
{
List <Guid> folderids = new List <Guid>();
foreach (var item in methodsetting.ParameterBinding)
{
if (item.Key.ToLower() == "folderid")
{
string strguid = item.Value.Binding;
Guid folderid = default(Guid);
if (System.Guid.TryParse(strguid, out folderid))
{
folderids.Add(folderid);
}
}
}
return(folderids);
}
public static void Compute(IDataMethodSetting methodsetting, SiteDb sitedb)
{
var values = methodsetting.ParameterBinding.Values;
var allfolderids = GetFolderIds(methodsetting);
var existings = sitedb.Relations.GetRelations(methodsetting.Id);
foreach (var item in existings)
{
if (!allfolderids.Contains(item.objectYId))
{
sitedb.Relations.Delete(item.Id);
}
}
foreach (var item in allfolderids)
{
sitedb.Relations.AddOrUpdate(methodsetting.Id, item, ConstObjectType.DataMethodSetting, ConstObjectType.Folder);
}
}
public DataMethodViewModel Add(ApiCall call)
{
DataMethodViewModel viewmodel = call.Context.Request.Model as DataMethodViewModel;
if (viewmodel.IsNew)
{
var methodhash = viewmodel.MethodSignatureHash;
IDataMethodSetting originalSetting = GlobalDb.DataMethodSettings.Query.Where(o => o.MethodSignatureHash == methodhash).FirstOrDefault();
DataMethodSetting newMethodSetting = new DataMethodSetting
{
MethodName = viewmodel.MethodName,
ParameterBinding = viewmodel.ParameterBinding,
Parameters = viewmodel.Parameters,
Description = viewmodel.Description,
OriginalMethodName = originalSetting.OriginalMethodName,
MethodSignatureHash = originalSetting.MethodSignatureHash,
DeclareType = originalSetting.DeclareType,
ReturnType = originalSetting.ReturnType,
DeclareTypeHash = originalSetting.DeclareTypeHash,
};
if (!viewmodel.IsPublic)
{
newMethodSetting.MethodName = System.Guid.NewGuid().ToString();
}
newMethodSetting.IsPublic = viewmodel.IsPublic;
call.WebSite.SiteDb().DataMethodSettings.AddOrUpdate(newMethodSetting, call.Context.User.Id);
viewmodel = UpdateViewModel(viewmodel, call.WebSite.SiteDb(), newMethodSetting);
}
else
{
var dataMethodSetting = call.WebSite.SiteDb().DataMethodSettings.Get(viewmodel.Id);
dataMethodSetting.ParameterBinding = viewmodel.ParameterBinding;
dataMethodSetting.Description = viewmodel.Description;
call.WebSite.SiteDb().DataMethodSettings.AddOrUpdate(dataMethodSetting, call.Context.User.Id);
viewmodel = UpdateViewModel(viewmodel, call.WebSite.SiteDb(), dataMethodSetting);
}
return(viewmodel);
}
public static DataMethodCompiled GetCompiledMethod(SiteDb SiteDb, Guid MethodId)
{
Guid id = GetId(SiteDb, MethodId);
lock (_lock)
{
DataMethodCompiled compiled;
if (MethodCache.TryGetValue(id, out compiled))
{
return(compiled);
}
// Global does not have site id.
if (MethodCache.TryGetValue(MethodId, out compiled))
{
return(compiled);
}
IDataMethodSetting DataMethod = SiteDb.DataMethodSettings.Get(MethodId);
if (DataMethod != null)
{
compiled = new DataMethodCompiled(DataMethod);
MethodCache[id] = compiled;
return(compiled);
}
DataMethod = Data.GlobalDb.DataMethodSettings.Get(MethodId);
if (DataMethod != null)
{
compiled = new DataMethodCompiled(DataMethod);
MethodCache[MethodId] = compiled;
return(compiled);
}
}
return(null);
}
private static string _GetSampleData(IDataMethodSetting setting)
{
string sample = null;
foreach (var item in setting.ParameterBinding)
{
if (item.Key.ToLower() == Kooboo.Sites.DataSources.ScriptSourceManager.SampleResponseFieldName.ToLower())
{
sample = item.Value.Binding;
}
}
if (sample == null)
{
foreach (var item in setting.ParameterBinding)
{
if (item.Key.ToLower().Contains("url"))
{
sample = Lib.Helper.HttpHelper.Get <string>(item.Value.Binding);
}
}
}
return(sample);
}
public static TypeInfoModel GetFields(SiteDb siteDb, IDataMethodSetting setting)
{
var model = new TypeInfoModel();
model.Id = setting.Id;
model.Name = setting.MethodName;
model.DeclareType = setting.DeclareType;
model.ItemFields = new List <TypeFieldModel>();
model.IsPublic = setting.IsPublic;
var type = TypeCache.GetType(setting.ReturnType);
if (type == null)
{
return(model);
}
model.ModelType = type.Name;
model.Enumerable = TypeHelper.IsCollection(type);
model.IsPagedResult = setting.IsPagedResult;
if (model.Enumerable)
{
type = TypeHelper.GetEnumberableType(type);
}
if (type == typeof(TextContentViewModel))
{
var folderIdKey = setting.ParameterBinding.Keys.FirstOrDefault(it => Isfolderid(it));
ParameterBinding binding;
if (!String.IsNullOrEmpty(folderIdKey) && setting.ParameterBinding.TryGetValue(folderIdKey, out binding))
{
Guid folderId;
if (Guid.TryParse(binding.Binding, out folderId))
{
var folder = siteDb.ContentFolders.Get(folderId);
if (folder != null)
{
model.ItemFields = GetContentTypeField(siteDb, folder.ContentTypeId);
foreach (var item in folder.Category)
{
var catfolder = siteDb.ContentFolders.Get(item.FolderId);
if (catfolder != null)
{
TypeFieldModel fieldmodel = new TypeFieldModel();
fieldmodel.Name = item.Alias;// catfolder.Name;
fieldmodel.Fields = GetContentTypeField(siteDb, catfolder.ContentTypeId);
fieldmodel.IsComplexType = true;
fieldmodel.Enumerable = item.Multiple;
model.ItemFields.Add(fieldmodel);
}
}
foreach (var item in folder.Embedded)
{
var embedfolder = siteDb.ContentFolders.Get(item.FolderId);
if (embedfolder != null)
{
TypeFieldModel fieldmodel = new TypeFieldModel();
fieldmodel.Name = item.Alias; //embedfolder.Name;
fieldmodel.Fields = GetContentTypeField(siteDb, embedfolder.ContentTypeId);
fieldmodel.IsComplexType = true;
fieldmodel.Enumerable = true;
model.ItemFields.Add(fieldmodel);
}
}
}
}
}
}
//else if (type == typeof(Kooboo.Sites.Ecommerce.ViewModel.ProductViewModel))
//{
// var alltype = siteDb.ProductType.All().Select(o=>o.Id).ToList();
// model.ItemFields = GetProductTypeField(siteDb, alltype);
//}
else if (type == typeof(Data.Definition.IJson))
{
// get sample and return.
var sample = _GetSampleData(setting);
if (!string.IsNullOrEmpty(sample))
{
model.ItemFields = GetJsonTypeFields(sample);
}
}
else if (type == typeof(Data.Definition.IXml))
{
var sample = _GetSampleData(setting);
if (!string.IsNullOrEmpty(sample))
{
model.ItemFields = GetXmlTypeFields(sample);
}
}
else
{
model.ItemFields = GetTypeFields(type);
}
return(model);
}
private DataMethodViewModel UpdateViewModel(DataMethodViewModel model, SiteDb siteDb, IDataMethodSetting setting)
{
var typeInfo = DataSourceHelper.GetFields(siteDb, setting);
model.IsGlobal = setting.IsGlobal;
model.MethodName = setting.MethodName;
model.ParameterBinding = setting.ParameterBinding;
model.Description = setting.Description;
model.Parameters = setting.Parameters;
model.Id = setting.Id;
model.OriginalMethodName = setting.OriginalMethodName;
model.MethodSignatureHash = setting.MethodSignatureHash;
model.DeclareType = setting.DeclareType;
model.IsGlobal = setting.IsGlobal;
model.ReturnType = setting.ReturnType;
model.IsPagedResult = setting.IsPagedResult;
model.ItemFields = typeInfo.ItemFields;
model.Enumerable = typeInfo.Enumerable;
model.IsPublic = setting.IsPublic;
return(model);
}
public DataMethodCompiled(IDataMethodSetting methodsetting)
{
Type type = Kooboo.Data.TypeCache.GetType(methodsetting.DeclareType);
this.DeclareType = type;
if (methodsetting.IsKScript)
{
this.IsKScript = true;
this.CodeId = methodsetting.CodeId;
this.Parameters = methodsetting.Parameters;
this.ParameterBindings = new Dictionary <string, ParameterBinding>();
if (methodsetting.ParameterBinding != null)
{
foreach (var item in methodsetting.ParameterBinding)
{
if (item.Key.ToLower() != Kooboo.Sites.DataSources.ScriptSourceManager.SampleResponseFieldName.ToLower())
{
this.ParameterBindings.Add(item.Key, item.Value);
}
}
}
}
else
{
Type returntype = Kooboo.Data.TypeCache.GetType(methodsetting.ReturnType);
this.ReturnType = returntype;
this.OriginalMethodName = methodsetting.OriginalMethodName;
Parameters = methodsetting.Parameters;
ParameterBindings = methodsetting.ParameterBinding;
this.IsStatic = methodsetting.IsStatic;
this.IsVoid = methodsetting.IsVoid;
List <Type> paratypes = new List <Type>();
foreach (var item in methodsetting.Parameters.Values)
{
Type paratype = Kooboo.Data.TypeCache.GetType(item);
paratypes.Add(paratype);
}
if (methodsetting.IsStatic)
{
if (methodsetting.IsVoid)
{
StaticVoid = Lib.Reflection.TypeHelper.CompileStaticAction(type, methodsetting.OriginalMethodName, paratypes);
}
else
{
StaticFunc = Lib.Reflection.TypeHelper.CompileStaticFunc(type, methodsetting.OriginalMethodName, paratypes);
}
}
else
{
if (methodsetting.IsVoid)
{
Void = Lib.Reflection.TypeHelper.CompileAction(type, methodsetting.OriginalMethodName, paratypes);
}
else
{
Func = Lib.Reflection.TypeHelper.CompileFunc(type, methodsetting.OriginalMethodName, paratypes);
}
}
}
}
