private void login1_OnLoginOk(ComponentModel.LoginEventArgs args)
{
IAbreCaixa caixa = null;
abreCaixaNovamente:
try
{
caixa = new AbreCaixa().PermiteAbrir(Settings.MachineName, DateTime.Now);
}
catch (PDVObrigatorio)
{
if (!PDV.Create(true).IsNullOrEmpty())
goto abreCaixaNovamente;
}
//tem que existir um caixa aberto para este operador.
if (caixa == null)
{
MessageBox.Show("Não foi permitido abrir o caixa para este PDV.", "Aviso!", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return;
}
IImpressora impressora = null;
try
{
impressora = OpenPOS.ECF.ECF.Create(caixa.Caixa.PDV);
}
catch (Exception ex)
{
MessageBox.ShowError(ex, false);
return;
}
//-------------------------------------------------------------------------
// Se tem caixa aberto, impressora e o usuário for um operador de caixa ou fiscal de caixa, continua.
//-------------------------------------------------------------------------
if (args.Usuario.Is(new TipoUsuario((string)Settings.Setting.OperadorCaixa)) ||
args.Usuario.Is(new TipoUsuario((string)Settings.Setting.FiscalCaixa)))
{
Settings.ECF.ECFAtual = impressora;
Settings.PDV.AberturaCaixa.Caixa = caixa.Caixa;
if (args.Usuario.Is(new TipoUsuario((string)Settings.Setting.FiscalCaixa)))
Settings.PDV.OperadorCaixaAtual = new FiscalCaixa(args.Usuario.GUID);
else
Settings.PDV.OperadorCaixaAtual = args.Usuario;
if (Unimake.Convert.ToBoolean(Settings.Setting.EmissaoConsumidorFinalNFCe))
frmVendaCF.IniciaVendaNFCe();
else
frmVendaCF.IniciaVenda();
Close();
}
else
{
MessageBox.Show("Este usuário não é um operador de caixa");
}
}
/// <summary>
/// Inspect the configuration associated with the component
/// and populates the parameter model collection accordingly
/// </summary>
/// <param name = "kernel"></param>
/// <param name = "model"></param>
public virtual void ProcessModel(IKernel kernel, ComponentModel model)
{
if (model.Configuration == null)
{
return;
}
var parameters = model.Configuration.Children["parameters"];
if (parameters == null)
{
return;
}
foreach (var parameter in parameters.Children)
{
var name = parameter.Name;
var value = parameter.Value;
if (value == null && parameter.Children.Count != 0)
{
var parameterValue = parameter.Children[0];
//model.Parameters.Add(name, parameterValue);
}
else
{
//model.Parameters.Add(name, value);
}
}
// Experimental code
//InspectCollections(model);
}
private void backgroundWorker1_DoWork_downloadBuild(object sender, ComponentModel.DoWorkEventArgs e)
{
try
{
if (!Directory.Exists(SetingClass.pDir + "\\" + SetingClass.gDir + "\\builds"))
Directory.CreateDirectory(SetingClass.pDir + "\\" + SetingClass.gDir + "\\builds");
Directory.CreateDirectory(SetingClass.pDir + "\\" + SetingClass.gDir + "\\builds\\" + SetingClass.selectedBuild.ID);
HttpWebRequest buildFileWebRequest = (HttpWebRequest)WebRequest.Create(SetingClass.repoLink + "/builds/" + SetingClass.selectedBuild.ID + ".json");
HttpWebResponse buildFileWebResponse = (HttpWebResponse)buildFileWebRequest.GetResponse();
Stream ReceiveStream = buildFileWebResponse.GetResponseStream();
StreamReader buildsListSR = new StreamReader(ReceiveStream, Encoding.UTF8);
string buildsListJSON = buildsListSR.ReadToEnd();
BuildInfo buildFiles = jss.Deserialize<BuildInfo>(buildsListJSON);
foreach (Item item in buildFiles.fileList)
{
if (!Directory.Exists(new FileInfo(SetingClass.pDir + "\\" + SetingClass.gDir + "\\builds\\" + SetingClass.selectedBuild.ID + item.localPath).DirectoryName))
Directory.CreateDirectory(new FileInfo(SetingClass.pDir + "\\" + SetingClass.gDir + "\\builds\\" + SetingClass.selectedBuild.ID + item.localPath).DirectoryName);
DownloadBuild.ReportProgress(0, "Загрузка " + item.name);
client.DownloadFile(SetingClass.repoLink + item.sitePath, SetingClass.pDir + "\\" + SetingClass.gDir + "\\builds\\" + SetingClass.selectedBuild.ID + item.localPath);
}
}
catch (Exception ex)
{
logError(ex);
Close();
}
}
/// <summary>
/// Constructor for SessionFactoryActivator
/// </summary>
/// <param name="model"></param>
/// <param name="kernel"></param>
/// <param name="onCreation"></param>
/// <param name="onDestruction"></param>
public SessionFactoryActivator(ComponentModel model,
IKernelInternal kernel,
ComponentInstanceDelegate onCreation,
ComponentInstanceDelegate onDestruction)
: base(model, kernel, onCreation, onDestruction)
{
}
/// <summary>
/// Tries to configure the ComponentModel based on attributes.
/// </summary>
/// <param name="model">The model.</param>
private void ConfigureBasedOnAttributes(ComponentModel model)
{
if (model.Implementation.IsDefined(typeof(TransactionalAttribute), true))
{
metaStore.CreateMetaFromType(model.Implementation);
}
}
public override bool CanConvertFrom(ComponentModel.ITypeDescriptorContext context, Type sourceType)
{
if(sourceType == typeof(string))
return true;
return base.CanConvertFrom(context, sourceType);
}
public Field(int index, string name, int length, ComponentModel.Validator.IValidator validator)
{
mIndex = index;
mName = name;
Length = length;
Validator = validator;
}
public bool CanResolve(CreationContext context, ISubDependencyResolver contextHandlerResolver,
ComponentModel model,
DependencyModel dependency)
{
return dependency.TargetType != null &&
dependency.TargetType.IsArray &&
kernel.HasComponent(dependency.TargetType.GetElementType());
}
public override object ConvertFrom(ComponentModel.ITypeDescriptorContext context, Globalization.CultureInfo culture, object value)
{
if(value is string)
{
return DataUri.Parse((string)value);
}
return base.ConvertFrom(context, culture, value);
}
public ComponentModel BuildModel(IComponentModelDescriptor[] customContributors)
{
var model = new ComponentModel();
Array.ForEach(customContributors, c => c.BuildComponentModel(kernel, model));
contributors.ForEach(c => c.ProcessModel(kernel, model));
Array.ForEach(customContributors, c => c.ConfigureComponentModel(kernel, model));
return model;
}
public void ConfigureComponentModel(IKernel kernel, ComponentModel model)
{
if (model.HasInterceptors && model.Implementation.IsInterface)
{
//var options = model.ObtainProxyOptions();
//options.OmitTarget = true;
}
}
public bool CanResolve(CreationContext context, ISubDependencyResolver contextHandlerResolver,
ComponentModel model,
DependencyModel dependency)
{
var targetType = dependency.TargetItemType;
return targetType != null &&
targetType.IsArray &&
(allowEmptyArray || kernel.HasComponent(targetType.GetElementType()));
}
/// <summary>
/// Should return an instance of a service or property values as
/// specified by the dependency model instance.
/// It is also the responsibility of <see cref="T:Castle.MicroKernel.IDependencyResolver" />
/// to throw an exception in the case a non-optional dependency
/// could not be resolved.
/// </summary>
/// <param name="context"> Creation context, which is a resolver itself </param>
/// <param name="contextHandlerResolver"> Parent resolver - normally the IHandler implementation </param>
/// <param name="model"> Model of the component that is requesting the dependency </param>
/// <param name="dependency"> The dependency model </param>
/// <returns> The dependency resolved value or null </returns>
public object Resolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
{
if (this.CanResolve(context, contextHandlerResolver, model, dependency))
{
if (dependency.TargetType == typeof(ILog))
{
return LogManager.GetLogger(model.Implementation);
}
}
return null;
}
/// <summary>
/// Checks if the type implements <see cref = "IInitializable" /> and or
/// <see cref = "IDisposable" /> interfaces.
/// </summary>
/// <param name = "kernel"></param>
/// <param name = "model"></param>
public virtual void ProcessModel(IKernel kernel, ComponentModel model)
{
if (model == null)
{
throw new ArgumentNullException("model");
}
if (IsLateBoundComponent(model))
{
//ProcessLateBoundModel(model);
return;
}
ProcessModel(model);
}
public object Resolve(CreationContext context, ISubDependencyResolver contextHandlerResolver,
ComponentModel model,
DependencyModel dependency)
{
var targetType = dependency.TargetType;
var elementType = targetType.GetGenericArguments()[0];
var items = kernel.ResolveAll(elementType, null);
var listType = typeof(List<>).MakeGenericType(elementType);
var list = Activator.CreateInstance(listType, items);
return list;
}
public void ConfigureComponentModel(IKernel kernel, ComponentModel model)
{
if (dictionary != null)
{
foreach (DictionaryEntry property in dictionary)
{
model.ExtendedProperties[property.Key] = property.Value;
}
}
if (properties != null)
{
Array.ForEach(properties, p => model.ExtendedProperties[p.Key] = p.Value);
}
}
/*private void ProcessLateBoundModel(ComponentModel model)
{
var commission = new LateBoundCommissionConcerns();
if (model.Services.Any(s => s.Is<IInitializable>()))
{
model.Lifecycle.Add(InitializationConcern.Instance);
}
else
{
commission.AddConcern<IInitializable>(InitializationConcern.Instance);
}
if (model.Services.Any(s => s.Is<ISupportInitialize>()))
{
model.Lifecycle.Add(SupportInitializeConcern.Instance);
}
else
{
commission.AddConcern<ISupportInitialize>(SupportInitializeConcern.Instance);
}
if (commission.HasConcerns)
{
model.Lifecycle.Add(commission);
}
if (model.Services.Any(s => s.Is<IDisposable>()))
{
model.Lifecycle.Add(DisposalConcern.Instance);
}
else
{
var decommission = new LateBoundDecommissionConcerns();
decommission.AddConcern<IDisposable>(DisposalConcern.Instance);
model.Lifecycle.Add(decommission);
}
}*/
private void ProcessModel(ComponentModel model)
{
if (model.Implementation.Is<IInitializable>())
{
//model.Lifecycle.Add(InitializationConcern.Instance);
}
if (model.Implementation.Is<ISupportInitialize>())
{
//model.Lifecycle.Add(SupportInitializeConcern.Instance);
}
if (model.Implementation.Is<IDisposable>())
{
//model.Lifecycle.Add(DisposalConcern.Instance);
}
}
public bool CanResolve(CreationContext context, ISubDependencyResolver contextHandlerResolver,
ComponentModel model,
DependencyModel dependency)
{
var targetType = dependency.TargetType;
if (targetType.IsGenericType &&
targetType.GetGenericTypeDefinition() == typeof(IList<>))
{
var elementType = targetType.GetGenericArguments()[0];
return kernel.HasComponent(elementType);
}
return false;
}
private static void KernelComponentDestroyed(ComponentModel model, object instance)
{
var shouldManage = false;
var value = model.ExtendedProperties[ManageWcfSessionsKey];
if (value != null)
{
shouldManage = (bool)value;
}
if (!shouldManage)
{
return;
}
var communicationObject = instance as ICommunicationObject;
if (communicationObject != null)
{
try
{
if (communicationObject.State != CommunicationState.Faulted)
{
communicationObject.Close();
}
else
{
communicationObject.Abort();
}
}
catch (CommunicationException)
{
communicationObject.Abort();
}
catch (TimeoutException)
{
communicationObject.Abort();
}
catch (Exception)
{
communicationObject.Abort();
throw;
}
}
}
private void CheckBuild_DoWork(object sender, ComponentModel.DoWorkEventArgs e)
{
try
{
HttpWebRequest buildFileWebRequest = (HttpWebRequest)WebRequest.Create(SetingClass.repoLink + "builds/" + SetingClass.selectedBuild.ID + ".json");
HttpWebResponse buildFileWebResponse = (HttpWebResponse)buildFileWebRequest.GetResponse();
Stream ReceiveStream = buildFileWebResponse.GetResponseStream();
StreamReader buildsListSR = new StreamReader(ReceiveStream, Encoding.UTF8);
string buildsListJSON = buildsListSR.ReadToEnd();
BuildInfo buildInfo = jss.Deserialize<BuildInfo>(buildsListJSON);
foreach (Item item in buildInfo.fileList)
{
if (!File.Exists(SetingClass.pDir + "\\" + SetingClass.gDir + "\\builds\\" + SetingClass.selectedBuild.ID + item.localPath))
{
if (!Directory.Exists(new FileInfo(SetingClass.pDir + "\\" + SetingClass.gDir + "\\builds\\" + SetingClass.selectedBuild.ID + item.localPath).DirectoryName))
Directory.CreateDirectory(new FileInfo(SetingClass.pDir + "\\" + SetingClass.gDir + "\\builds\\" + SetingClass.selectedBuild.ID + item.localPath).DirectoryName);
CheckBuild.ReportProgress(0, "Загрузка " + item.name);
client.DownloadFile(SetingClass.repoLink + item.sitePath, SetingClass.pDir + "\\" + SetingClass.gDir + "\\builds\\" + SetingClass.selectedBuild.ID + item.localPath);
}
else if (item.hash != ComputeMD5Checksum(SetingClass.pDir + "\\" + SetingClass.gDir + "\\builds\\" + SetingClass.selectedBuild.ID + "\\" + item.localPath))
{
File.Delete(SetingClass.pDir + "\\" + SetingClass.gDir + "\\builds\\" + SetingClass.selectedBuild.ID + item.localPath);
CheckBuild.ReportProgress(0, "Загрузка " + item.name);
client.DownloadFile(SetingClass.repoLink + item.sitePath, SetingClass.pDir + "\\" + SetingClass.gDir + "\\builds\\" + SetingClass.selectedBuild.ID + item.localPath);
}
}
foreach (string fileName in Directory.GetFiles(SetingClass.pDir + "\\" + SetingClass.gDir + "\\builds\\" + SetingClass.selectedBuild.ID + "\\mods\\", "*.jar", SearchOption.AllDirectories))
{
if (!searchMods(buildInfo, fileName))
{
CheckBuild.ReportProgress(0, "Удаление " + fileName);
File.Delete(fileName);
}
}
}
catch (Exception ex)
{
logError(ex);
Close();
}
}
public object Resolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
{
if (this.CanResolve(context, contextHandlerResolver, model, dependency))
{
if (dependency.TargetType.IsArray)
{
Type resolveType = dependency.TargetType.GetElementType();
return this.kernel.ResolveAll(resolveType);
}
if (dependency.TargetType.IsGenericType)
{
return this.kernel.ResolveAll(dependency.TargetType.GetGenericArguments()[0]);
}
}
return null;
}
/// <summary>
/// Tries to obtain transaction configuration based on
/// the component configuration or (if not available) check
/// for the attributes.
/// </summary>
/// <param name="kernel">The kernel.</param>
/// <param name="model">The model.</param>
public override void ProcessModel(IKernel kernel, ComponentModel model)
{
if (metaStore == null)
{
metaStore = kernel.Resolve<TransactionMetaInfoStore>();
}
if (IsMarkedWithTransactional(model.Configuration))
{
base.ProcessModel(kernel, model);
}
else
{
AssertThereNoTransactionOnConfig(model);
ConfigureBasedOnAttributes(model);
}
Validate(model, metaStore);
AddTransactionInterceptorIfIsTransactional(model, metaStore);
}
/// <summary>
/// Ocorre ao clicar no botão Novo da Toolbar
/// </summary>
/// <param name="sender">Objeto que disparou o evento</param>
/// <param name="args">Argumento do evento gerado</param>
protected void Toolbar_OnNewClick(ComponentModel.Toolbar sender, ComponentModel.ComponentModelEventArgs args)
{
CarregarDAVButton.Enabled = true;
MesclarPVButton.Enabled = false;
}
public Task AddOrUpdateAsync(ComponentModel componentRegistrationModel)
{
_logger.LogWarning($"Mock {nameof(AddOrUpdateAsync)} method was called");
return(Task.FromResult(true));
}
public bool CanResolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model,
DependencyModel dependency)
{
return Result != null;
}
public abstract object Create(IKernel kernel, object instance, ComponentModel model, CreationContext context,
params object[] constructorArguments);
public void SetInterceptedComponentModel(ComponentModel target)
{
m_target = target;
}
public object Resolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model,
DependencyModel dependency)
{
return(new SatiWatcher());
}
public bool CanResolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
{
return(Result != null);
}
public bool HasInterceptors(ComponentModel model)
{
return(model.Services.Any(s => s == typeof(IWatcher)) && Interceptors == InterceptorKind.Dummy);
}
public bool CanResolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model,
DependencyModel dependency)
{
return(dependency.TargetType == typeof(IWatcher));
}
private void RegisterMethodsForFastAccess(MethodInfo[] methods,
String signature, MethodMetaModel metaModel, ComponentModel model)
{
foreach (MethodInfo method in methods)
{
if (signature != null && signature.Length != 0)
{
model.MethodMetaModels.MethodInfo2Model[method] = metaModel;
}
else
{
if (!model.MethodMetaModels.MethodInfo2Model.Contains(method))
{
model.MethodMetaModels.MethodInfo2Model[method] = metaModel;
}
}
}
}
public void ConfigureComponentModel(IKernel kernel, ComponentModel model)
{
}
public void BuildComponentModel(IKernel kernel, ComponentModel model)
{
var options = ProxyUtil.ObtainProxyOptions(model, true);
options.Hook = hook;
}
public object Resolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
{
return(this.kernel.Resolve(dependency.DependencyKey, typeof(DirectoryInfo)));
}
private string GetNameDescription(ComponentModel componentModel)
{
return(componentModel.ComponentName.SetByUser ? componentModel.ComponentName.Name : componentModel.ToString());
}
/// <summary>
/// Sets the intercepted ComponentModel.
/// </summary>
/// <param name = "target">The targets ComponentModel.</param>
public void SetInterceptedComponentModel(ComponentModel target)
{
metaInfo = metaStore.GetMetaFor(target.Implementation);
}
private void CreateServiceHostWhenHandlerIsValid(IHandler handler, IWcfServiceModel serviceModel, ComponentModel model)
{
if (serviceModel.ShouldOpenEagerly.GetValueOrDefault(OpenServiceHostsEagerly) ||
handler.CurrentState == HandlerState.Valid)
{
CreateAndOpenServiceHost(serviceModel, model);
}
else
{
HandlersChangedDelegate onStateChanged = null;
onStateChanged = (ref bool stateChanged) =>
{
if (handler.CurrentState == HandlerState.Valid && onStateChanged != null)
{
kernel.HandlersChanged -= onStateChanged;
onStateChanged = null;
CreateAndOpenServiceHost(serviceModel, model);
}
};
kernel.HandlersChanged += onStateChanged;
}
}
protected void Page_Load(object sender, EventArgs e)
{
List <long> groupids = bllPms.GetPmsGroupIDByUser(bll.WebsiteOwner);
if (groupids.Count > 0)
{
webpms_groups = Common.MyStringHelper.ListToStr(groupids, "", ",");
}
string key = this.Request["key"];
BLLJIMP.Model.Component nComponent = bll.GetComponentByKey(key, bll.WebsiteOwner);
if (nComponent == null)
{
Common.WebMessageBox.Show(this, "组件未找到");
return;
}
keyname = bll.GetComponentNameByKey(key);
ComponentModel componentModel = bll.GetByKey <ComponentModel>("AutoId", nComponent.ComponentModelId.ToString());
if (componentModel == null)
{
Common.WebMessageBox.Show(this, "模板未找到");
return;
}
List <ComponentModelField> componentModelFields = bll.GetListByKey <ComponentModelField>("ComponentModelKey", componentModel.ComponentModelKey)
.OrderBy(p => p.ComponentFieldSort).ToList();
dynamic cModel = new
{
component_model_id = componentModel.AutoId,
component_model_name = componentModel.ComponentModelName,
component_model_type = componentModel.ComponentModelType,
component_model_link_url = componentModel.ComponentModelLinkUrl,
component_model_html_url = componentModel.ComponentModelHtmlUrl,
component_model_fields = (from p in componentModelFields
select new
{
component_field_id = p.AutoId,
component_field = p.ComponentField,
component_field_name = p.ComponentFieldName,
component_field_type = p.ComponentFieldType,
component_field_data_type = p.ComponentFieldType,
component_field_data_value = p.ComponentFieldDataValue
})
};
component = JsonConvert.SerializeObject(nComponent);
component_model = JsonConvert.SerializeObject(cModel);
//读取广告
StringBuilder sbWhere = new StringBuilder(string.Format(" WebSiteOwner='{0}'", bll.WebsiteOwner));
var slideData = bll.GetColList <BLLJIMP.Model.Slide>(int.MaxValue, 1, sbWhere.ToString(), "AutoID,Type");
dynamic result = slideData.Select(p => p.Type).Distinct().OrderBy(p => p);
slides = JsonConvert.SerializeObject(result);
//读取组件
sbWhere = new StringBuilder();
sbWhere.AppendFormat(" WebsiteOwner='{0}'", bll.WebsiteOwner);
sbWhere.AppendFormat(" AND ComponentType != 'page' ");
var componentList = bll.GetColList <BLLJIMP.Model.Component>(int.MaxValue, 1, sbWhere.ToString(), "AutoId,ComponentName,ComponentType");
result = from p in componentList
select new
{
component_id = p.AutoId,
component_name = p.ComponentName,
component_type = p.ComponentType
};
common_components = JsonConvert.SerializeObject(result);
//读取底部工具栏
sbWhere = new StringBuilder();
sbWhere.AppendFormat(" WebsiteOwner='{0}' OR WebsiteOwner Is Null ", bll.WebsiteOwner);
List <CompanyWebsite_ToolBar> dataList = bll.GetColList <CompanyWebsite_ToolBar>(int.MaxValue, 1, sbWhere.ToString(), "AutoID,KeyType,UseType");
result = (from p in dataList
select new
{
key_type = p.KeyType,
use_type = p.UseType
}).Distinct();
toolbars = JsonConvert.SerializeObject(result);
int total = 0;
//读取商品分类
List <BLLJIMP.Model.WXMallCategory> mallCateList = bllMall.GetCategoryList(1, int.MaxValue, null, out total);
result = (from p in mallCateList
select new
{
cate_id = p.AutoID,
cate_name = p.CategoryName
}).Distinct();
mall_cates = JsonConvert.SerializeObject(result);
//读取商品标签
List <BLLJIMP.Model.MemberTag> tagList = bllTag.GetTags(bllTag.WebsiteOwner, null, 1, int.MaxValue, out total, "Mall");
result = tagList.OrderBy(p => p.TagName).Select(p => p.TagName).Distinct();
mall_tags = JsonConvert.SerializeObject(result);
List <ArticleCategory> artCateList = bllArticleCategory.GetCateList(out total, "Article", null, bllArticleCategory.WebsiteOwner, int.MaxValue, 1);
List <ListItem> artCateItemList = new List <ListItem>();
if (artCateList.Count > 0)
{
artCateItemList = bllMyCategories.GetCateListItem(bllMyCategories.GetCommCateModelList("AutoID", "PreID", "CategoryName", artCateList), 0);
}
result = (from p in artCateItemList
select new
{
cate_id = p.Value,
cate_name = p.Text
}).Distinct();
art_cates = JsonConvert.SerializeObject(result);
List <ArticleCategory> actCateList = bllArticleCategory.GetCateList(out total, "Activity", null, bllArticleCategory.WebsiteOwner, int.MaxValue, 1);
List <ListItem> actCateItemList = new List <ListItem>();
if (actCateList.Count > 0)
{
actCateItemList = bllMyCategories.GetCateListItem(bllMyCategories.GetCommCateModelList("AutoID", "PreID", "CategoryName", actCateList), 0);
}
result = (from p in actCateItemList
select new
{
cate_id = p.Value,
cate_name = p.Text
}).Distinct();
act_cates = JsonConvert.SerializeObject(result);
WebsiteInfo model = bllWeisite.GetWebsiteInfo();
if (model != null && !string.IsNullOrEmpty(model.WeiXinBindDomain))
{
strDomain = model.WeiXinBindDomain;
}
}
public object Resolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
{
return(_kernel.Resolve(dependency.TargetType));
}
public abstract bool RequiresTargetInstance(IKernel kernel, ComponentModel model);
public void ProcessRequest(HttpContext context)
{
string data = context.Request["data"];
RequestModel requestModel = new RequestModel();
try
{
requestModel = JSONHelper.JsonToModel <RequestModel>(data);
}
catch (Exception ex)
{
apiResp.msg = "json格式错误,请检查。";
apiResp.code = (int)APIErrCode.IsNotFound;
bll.ContextResponse(context, apiResp);
return;
}
if (string.IsNullOrWhiteSpace(requestModel.component_model_name))
{
apiResp.msg = "请录入组件库名称";
apiResp.code = (int)APIErrCode.IsNotFound;
bll.ContextResponse(context, apiResp);
return;
}
if (requestModel.component_model_fields.Count == 0)
{
apiResp.msg = "请录入组件库变量字段";
apiResp.code = (int)BLLJIMP.Enums.APIErrCode.IsNotFound;
bll.ContextResponse(context, apiResp);
return;
}
for (int i = 0; i < requestModel.component_model_fields.Count; i++)
{
if (string.IsNullOrWhiteSpace(requestModel.component_model_fields[i].component_field))
{
apiResp.msg = "请完善字段Key";
apiResp.code = (int)APIErrCode.IsNotFound;
bll.ContextResponse(context, apiResp);
return;
}
}
ComponentModel componentModel = bll.GetByKey <ComponentModel>("AutoId", requestModel.component_model_id.ToString());
if (componentModel == null)
{
apiResp.msg = "原组件库未找到";
apiResp.code = (int)APIErrCode.IsNotFound;
bll.ContextResponse(context, apiResp);
return;
}
componentModel.ComponentModelName = requestModel.component_model_name;
componentModel.ComponentModelType = requestModel.component_model_type;
componentModel.ComponentModelLinkUrl = requestModel.component_model_link_url;
componentModel.ComponentModelHtmlUrl = requestModel.component_model_html_url;
componentModel.IsDelete = requestModel.is_delete;
List <ComponentModelField> OldList = bll.GetListByKey <ComponentModelField>("ComponentModelKey", componentModel.ComponentModelKey);
List <ComponentModelField> AddComponentModelFields = new List <ComponentModelField>();
List <ComponentModelField> UpdateComponentModelFields = new List <ComponentModelField>();
List <ComponentModelField> DeleteComponentModelFields = new List <ComponentModelField>();
foreach (var item in requestModel.component_model_fields.Where(p => p.component_field_id == 0))
{
ComponentModelField temp = new ComponentModelField();
temp.ComponentModelKey = componentModel.ComponentModelKey;
temp.ComponentField = item.component_field;
temp.ComponentFieldName = item.component_field_name;
temp.ComponentFieldType = item.component_field_type;
temp.ComponentFieldDataType = item.component_field_data_type;
temp.ComponentFieldDataValue = item.component_field_data_value;
temp.ComponentFieldSort = item.component_field_sort;
AddComponentModelFields.Add(temp);
}
foreach (var item in OldList)
{
RequestFieldModel nField = requestModel.component_model_fields.FirstOrDefault(p => p.component_field_id == item.AutoId);
if (nField == null)
{
DeleteComponentModelFields.Add(item);
}
else
{
item.ComponentField = nField.component_field;
item.ComponentFieldName = nField.component_field_name;
item.ComponentFieldType = nField.component_field_type;
item.ComponentFieldDataType = nField.component_field_data_type;
item.ComponentFieldDataValue = nField.component_field_data_value;
item.ComponentFieldSort = nField.component_field_sort;
UpdateComponentModelFields.Add(item);
}
}
string errmsg = string.Empty;
if (bll.UpdateComponentModel(componentModel, AddComponentModelFields, UpdateComponentModelFields
, DeleteComponentModelFields, out errmsg))
{
apiResp.status = true;
apiResp.msg = "修改完成";
apiResp.code = (int)APIErrCode.IsSuccess;
}
else
{
apiResp.msg = errmsg;
apiResp.code = (int)APIErrCode.OperateFail;
}
bll.ContextResponse(context, apiResp);
}
public abstract object Create(IProxyFactoryExtension customFactory, IKernel kernel, ComponentModel model,
CreationContext context, params object[] constructorArguments);
public InterceptorReference[] SelectInterceptors(ComponentModel model)
{
return(new[] { InterceptorReference.ForType <ExceptionHandler>() });
}
public object Resolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model,
DependencyModel dependency)
{
return Result.Value;
}
private bool SkipRegistration(IKernelInternal internalKernel, ComponentModel componentModel)
{
return(ifComponentRegisteredIgnore && internalKernel.HasComponent(componentModel.Name));
}
public object Resolve(CreationContext context, ISubDependencyResolver contextHandlerResolver,
ComponentModel model,
DependencyModel dependency)
{
return kernel.ResolveAll(dependency.TargetType.GetElementType(), null);
}
protected int GetDataTipTextImpl(ITextBuffer subjectBuffer, TextSpan[] pSpan, out string pbstrText)
{
pbstrText = null;
var vsBuffer = EditorAdaptersFactory.GetBufferAdapter(subjectBuffer);
// TODO: broken in REPL
if (vsBuffer == null)
{
return(VSConstants.E_FAIL);
}
using (Logger.LogBlock(FunctionId.Debugging_VsLanguageDebugInfo_GetDataTipText, CancellationToken.None))
{
pbstrText = null;
if (pSpan == null || pSpan.Length != 1)
{
return(VSConstants.E_INVALIDARG);
}
var result = VSConstants.E_FAIL;
string pbstrTextInternal = null;
var waitIndicator = ComponentModel.GetService <IWaitIndicator>();
waitIndicator.Wait(
title: ServicesVSResources.Debugger,
message: ServicesVSResources.Getting_DataTip_text,
allowCancel: true,
action: waitContext =>
{
IServiceProvider serviceProvider = ComponentModel.GetService <SVsServiceProvider>();
var debugger = (IVsDebugger)serviceProvider.GetService(typeof(SVsShellDebugger));
var debugMode = new DBGMODE[1];
var cancellationToken = waitContext.CancellationToken;
if (ErrorHandler.Succeeded(debugger.GetMode(debugMode)) && debugMode[0] != DBGMODE.DBGMODE_Design)
{
var textSpan = pSpan[0];
var textSnapshot = subjectBuffer.CurrentSnapshot;
var document = textSnapshot.GetOpenDocumentInCurrentContextWithChanges();
if (document != null)
{
var languageDebugInfo = document.Project.LanguageServices.GetService <ILanguageDebugInfoService>();
if (languageDebugInfo != null)
{
var spanOpt = textSnapshot.TryGetSpan(textSpan);
if (spanOpt.HasValue)
{
var dataTipInfo = languageDebugInfo.GetDataTipInfoAsync(document, spanOpt.Value.Start, cancellationToken).WaitAndGetResult(cancellationToken);
if (!dataTipInfo.IsDefault)
{
var resultSpan = dataTipInfo.Span.ToSnapshotSpan(textSnapshot);
var textOpt = dataTipInfo.Text;
pSpan[0] = resultSpan.ToVsTextSpan();
result = debugger.GetDataTipValue((IVsTextLines)vsBuffer, pSpan, textOpt, out pbstrTextInternal);
}
}
}
}
}
});
pbstrText = pbstrTextInternal;
return(result);
}
}
public void ProcessModel(IKernel kernel, ComponentModel model)
{
model.RequiresGenericArguments = model.Services.Any(s => s.IsGenericTypeDefinition);
}
public DummyFormActivator(ComponentModel model, IKernelInternal kernel, ComponentInstanceDelegate onCreation, ComponentInstanceDelegate onDestruction)
: base(model, kernel, onCreation, onDestruction)
{
}
/// <summary>
/// Ocorre ao clicar no botão Salvar da Toolbar
/// </summary>
/// <param name="sender">Objeto que disparou o evento</param>
/// <param name="args">Argumento do evento gerado</param>
private void Toolbar_OnSaveClick(ComponentModel.Toolbar sender, ComponentModel.ComponentModelEventArgs args)
{
CarregarDAVButton.Enabled = true;
MesclarPVButton.Enabled = true;
}
public void Test_KernelRegister17()
{
var context = new ConventionalRegistrationContext(
Assembly.GetExecutingAssembly(),
LocalIocManager,
new ConventionalRegistrationConfig());
var descriptor = new FromAssemblyDescriptor(context.Assembly, Classes.MyFilter);
var result = new BasedOnDescriptor(new List <Type> {
typeof(AbpDbContext)
}, descriptor, Classes.MyFilter);
descriptor.Criterias.Add(result);
var kernel = new DefaultKernel();
Type[] baseTypes;
var type = typeof(MyDbContext);
Assert.IsTrue(result.Accepts(type, out baseTypes));
Assert.AreEqual(baseTypes.Length, 1);
Assert.AreEqual(baseTypes[0].Name, "AbpDbContext");
var defaults = CastleComponentAttribute.GetDefaultsFor(type);
Assert.IsNotNull(defaults);
var serviceTypes = result.WithService.GetServices(type, baseTypes);
Assert.AreEqual(serviceTypes.Count, 0);
Assert.AreEqual(defaults.Services.Length, 1);
serviceTypes = defaults.Services;
Assert.AreEqual(serviceTypes.ElementAt(0), typeof(MyDbContext));
var registration = Component.For(serviceTypes);
registration.ImplementedBy(type);
result.Configuration?.Invoke(registration);
Assert.IsNull(registration.Name);
Assert.IsNull(defaults.Name);
registration.RegisterOptionally();
var token = kernel.OptimizeDependencyResolution();
var services = registration.FilterServices(kernel);
Assert.AreEqual(services.Length, 1);
Assert.AreEqual(services[0], typeof(MyDbContext));
var builder = kernel.ComponentModelBuilder;
var customContributors = registration.GetContributors(services);
var model = new ComponentModel();
Array.ForEach(customContributors, c => c.BuildComponentModel(kernel, model));
Assert.AreEqual(builder.Contributors.Length, 11);
Assert.AreEqual(customContributors.Length, 2);
foreach (var construction in builder.Contributors)
{
if (construction is PropertiesDependenciesModelInspector)
{
var targetType = model.Implementation;
Assert.AreEqual(model.InspectionBehavior, PropertiesInspectionBehavior.Undefined);
model.InspectionBehavior =
(construction as PropertiesDependenciesModelInspector)
.GetInspectionBehaviorFromTheConfiguration(model.Configuration);
Assert.AreEqual(model.InspectionBehavior, PropertiesInspectionBehavior.All);
var bindingFlags = BindingFlags.Public | BindingFlags.Instance;
var properties = targetType.GetProperties(bindingFlags);
Assert.AreEqual(properties.Length, 7);
foreach (var property in properties)
{
Console.WriteLine(property.Name);
try
{
var canWrite = property.CanWrite;
}
catch
{
Console.WriteLine(@"CanWrite Fail, Construction:{0}, Property{1}", construction, property);
}
try
{
var parameters = property.GetIndexParameters();
}
catch
{
throw new NullReferenceException(@"GetIndexParameters Fail:" + property.Name);
}
try
{
var hasAttribute = property.HasAttribute <DoNotWireAttribute>();
}
catch
{
Console.WriteLine(@"HasAttribute Fail, Construction:{0}, Property{1}", construction, property);
}
}
break;
}
}
token?.Dispose();
}
private bool IsLateBoundComponent(ComponentModel model)
{
return typeof(LateBoundComponent) == model.Implementation;
}
public bool Checked(ComponentModel component)
{
return(checkedComponents.Add(component) == false);
}
public virtual bool CanResolve(CreationContext context, ISubDependencyResolver contextHandlerResolver,
ComponentModel model,
DependencyModel dependency)
{
return(HasAdditionalArguments && (CanResolveByKey(dependency) || CanResolveByType(dependency)));
}
public bool HasInterceptors(ComponentModel model)
{
return(model.Implementation.Namespace != null && (typeof(ExceptionHandler) != model.Implementation));
}
public object Resolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
{
return(Result.Value);
}
public object Resolve(CreationContext context, ISubDependencyResolver parentResolver,
ComponentModel model,
DependencyModel dependency)
{
return(kernel.ResolveAll(dependency.TargetType.GetElementType(), null));
}
public ViewPageComponentActivator(ComponentModel model, IKernel kernel, ComponentInstanceDelegate onCreation, ComponentInstanceDelegate onDestruction)
: base(model, kernel, onCreation, onDestruction)
{
}
public bool CanResolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
{
return(dependency.TargetType.GetTypeInfo().IsGenericType&& dependency.TargetType.GetGenericTypeDefinition() == typeof(IOptions <>));
}
