public static int GetOperationTcpVersion(OperationTypes operationType) { switch (operationType) { case OperationTypes.Ping: case OperationTypes.None: return(-1); case OperationTypes.Drop: return(-2); case OperationTypes.Subscription: return(SubscriptionTcpVersion); case OperationTypes.Replication: return(ReplicationTcpVersion); case OperationTypes.Cluster: return(ClusterTcpVersion); case OperationTypes.Heartbeats: return(HeartbeatsTcpVersion); case OperationTypes.TestConnection: return(TestConnectionTcpVersion); default: throw new ArgumentOutOfRangeException(nameof(operationType), operationType, null); } }
/// <summary> /// Initializes a new instance of the <see cref="ValidateWithDataErrorInfo"/> class. /// </summary> /// <param name="appliesWhen">The rule applies when.</param> /// <exception cref="ArgumentOutOfRangeException">appliesWhen;appliesWhen may only be a combination of Insert or Update</exception> public ValidateWithDataErrorInfo(OperationTypes appliesWhen) : base(appliesWhen) { if (appliesWhen.HasFlag(OperationTypes.Select) || appliesWhen.HasFlag(OperationTypes.Delete)) { throw new ArgumentOutOfRangeException("appliesWhen", appliesWhen, "appliesWhen may only be a combination of Insert or Update"); } }
/// <summary> /// Initializes a new instance of the <see cref="ValueRule"/> class. /// </summary> /// <param name="columnName">Name of the column.</param> /// <param name="valueFactory">The value factory.</param> /// <param name="appliesWhen">The applies when.</param> /// <exception cref="ArgumentOutOfRangeException">appliesWhen;appliesWhen may only be a combination of Insert, Update, or Delete</exception> public ValueRule(string columnName, ColumnValueGenerator valueFactory, OperationTypes appliesWhen) : base(columnName, appliesWhen) { if (appliesWhen.HasFlag(OperationTypes.Select)) throw new ArgumentOutOfRangeException("appliesWhen", appliesWhen, "appliesWhen may only be a combination of Insert, Update, or Delete"); ValueFactory = valueFactory; }
private void CheckOperationPermission(OperationTypes operationType) { if (!CurrentEmployee.AllowedOperationTypes.HasFlag(operationType)) { throw new Exception("У текущего сотрудника нет прав на осуществление операции"); } }
/// <summary> /// Initializes a new instance of the <see cref="UserDataRule" /> class. /// </summary> /// <param name="columnName">Name of the column.</param> /// <param name="appliesWhen">The rule can be applied to insert, update, and/or soft delete operations.</param> /// <exception cref="ArgumentOutOfRangeException">appliesWhen;appliesWhen may only be a combination of Insert, Update, or Delete</exception> /// <remarks> /// This will have no effect on hard deletes. /// </remarks> public DateTimeOffsetRule(string columnName, OperationTypes appliesWhen) : base(columnName, appliesWhen) { if (appliesWhen.HasFlag(OperationTypes.Select)) { throw new ArgumentOutOfRangeException("appliesWhen", appliesWhen, "appliesWhen may only be a combination of Insert, Update, or Delete"); } }
public static ExecuteOperation CreateOperations(OperationTypes operation) { ExecuteOperation execOperations; switch (operation) { case OperationTypes.add: execOperations = Add; break; case OperationTypes.substract: execOperations = Substract; break; case OperationTypes.multiply: execOperations = Multiply; break; case OperationTypes.divide: execOperations = Divide; break; default: execOperations = Add; break; } return(execOperations); }
public Employee CreateEmployee(string name, OperationTypes allowedOperationTypes) { var newEmployee = new Employee(Employees.Count, name, allowedOperationTypes); Employees.Add(newEmployee); return(newEmployee); }
/// <summary> /// Sets the source property value from a <see cref="JToken"/>. /// </summary> /// <param name="value">The source value.</param> /// <param name="json">The <see cref="JToken"/>.</param> /// <param name="operationType">The single <see cref="Mapper.OperationTypes"/> being performed to enable selection.</param> public void SetSrceValue(TSrce value, JToken json, OperationTypes operationType) { if (value == null) throw new ArgumentNullException(nameof(value)); SetSrceValue(value, (TSrceProperty)((IODataPropertyMapper)this).GetSrceValue(json, operationType), operationType); }
/// <summary> /// Maps the destination to the source. /// </summary> /// <param name="destinationEntity">The destination entity.</param> /// <param name="operationType">The single <see cref="Mapper.OperationTypes"/> being performed to enable selection.</param> /// <returns>The source entity.</returns> public TSrce MapToSrce(TDest destinationEntity, OperationTypes operationType = OperationTypes.Unspecified) { if (destinationEntity == null) { return(null); } var srce = new TSrce(); foreach (var map in Mappings) { if (map.OperationTypes.HasFlag(operationType)) { map.MapToSrce(destinationEntity, srce, operationType); } } srce = OnMapToSrce(destinationEntity, srce, operationType); if (srce != null && MapToSrceNullWhenIsInitial && srce is ICleanUp ic && ic.IsInitial) { return(null); } return(srce); }
/// <summary> /// Gets the source property value from a <see cref="JToken"/>. /// </summary> /// <param name="json">The <see cref="JToken"/>.</param> /// <param name="operationType">The single <see cref="Mapper.OperationTypes"/> being performed to enable selection.</param> /// <returns>The source value.</returns> object IODataPropertyMapper.GetSrceValue(JToken json, OperationTypes operationType) { if (json == null) throw new ArgumentNullException(nameof(json)); if (Converter != null) return (TSrceProperty)Converter.ConvertToSrce(Cleaner.Clean(json.ToObject(Converter.DestType))); if (!IsSrceComplexType) return json.ToObject<TSrceProperty>(); if (!json.HasValues) return null; var em = (IODataMapper)Mapper; if (SrceComplexTypeReflector.ComplexTypeCode == Reflection.ComplexTypeCode.Object) return (em == null) ? json.ToObject(SrceComplexTypeReflector.PropertyInfo.PropertyType) : em.MapFromOData(json, operationType); if (json.Type != JTokenType.Array) throw new MapperException($"Property '{SrcePropertyName}' has Type '{SrcePropertyType.Name}' and therefore expects a JTokenType.Array not JTokenType.{json.Type}."); if (em == null) return json.ToObject(SrceComplexTypeReflector.PropertyInfo.PropertyType); var vals = new List<Object>(); foreach (var jao in json.Children<JObject>()) { vals.Add(em.MapFromOData(jao, operationType)); } return SrceComplexTypeReflector.CreateValue(vals); }
public IOperation CreateOperation(OperationTypes operationType) { IOperation newOperation = null; switch (operationType) { case OperationTypes.Addition: newOperation = new AdditionOperation(); break; case OperationTypes.Subtraction: newOperation = new SubtractionOperation(); break; case OperationTypes.Multiplication: newOperation = new MultiplicationOperation(); break; case OperationTypes.Division: newOperation = new DivisionOperation(); break; case OperationTypes.Modulus: newOperation = new ModulusOperation(); break; case OperationTypes.Undefined: newOperation = new NullOperation(); break; } return(newOperation); }
public static List <Operation> GetOne(OperationTypes type, string ip, List <List <Value> > before = default, List <List <Value> > after = default) { return(new List <Operation>() { new Operation(type, ip, before, after) }); }
/// <summary> /// Creates a source entity mapping values from the <see cref="DatabaseParameters"/>. /// </summary> /// <param name="dr">The <see cref="DatabaseParameters"/>.</param> /// <param name="operationType">The single <see cref="Mapper.OperationTypes"/> being performed to enable selection.</param> /// <param name="data">An optional (additional) data object.</param> /// <returns>A <typeparamref name="TSrce"/> instance populated from the <see cref="DatabaseParameters"/>.</returns> public TSrce MapFromDb(DatabaseRecord dr, OperationTypes operationType = OperationTypes.Unspecified, object data = null) { if (dr == null) { throw new ArgumentNullException(nameof(dr)); } TSrce value = new TSrce(); foreach (IDatabasePropertyMapper <TSrce> map in Mappings) { if (map.OperationTypes.HasFlag(operationType) && map.MapDestToSrceWhen(dr)) { map.SetSrceValue(value, dr, operationType); } } value = OnMapFromDb(value, dr, operationType, data); if (value != null && MapFromDbNullWhenIsInitial && value is ICleanUp ic && ic.IsInitial) { return(null); } return(value); }
public static SupportedStatus OperationVersionSupported(OperationTypes operationType, int version, out int current) { current = -1; if (OperationsToSupportedProtocolVersions.TryGetValue(operationType, out var supportedProtocols) == false) { throw new ArgumentException($"This is a bug. Probably you forgot to add '{operationType}' operation " + $"to the '{nameof(OperationsToSupportedProtocolVersions)}' dictionary."); } for (var i = 0; i < supportedProtocols.Count; i++) { current = supportedProtocols[i]; if (current == version) { return(SupportedStatus.Supported); } if (current < version) { return(SupportedStatus.NotSupported); } } return(SupportedStatus.OutOfRange); }
public OperationItemControl(OperationTypes operation, bool isRoot) { InitializeComponent(); RanetHotButton add = new RanetHotButton() { Margin = new Thickness(5, 0, 0, 0) }; add.Click += new RoutedEventHandler(add_Click); add.Width = 18; add.Height = 18; add.Content = UiHelper.CreateIcon(UriResources.Images.AddHot16); LayoutRoot.Children.Add(add); Grid.SetColumn(add, 1); m_IsRoot = isRoot; operationControl.HorizontalContentAlignment = HorizontalAlignment.Stretch; operationControl.SelectionChanged += new SelectionChangedEventHandler(operationControl_SelectionChanged); operationControl.DropDownClosed += new EventHandler(operationControl_DropDownClosed); InitItems(); if (operationControl.Items.Count > 0) { operationControl.SelectedIndex = 0; } }
private void ShowEditForm(OrderEntity orderEntity, OperationTypes operationType) { //OrderForm caForm = CommonFunction.GetOrderForm(orderEntity); //caForm.Width = this.ActualWidth; //caForm.Height = this.ActualHeight; //caForm.Closed += (o, e) => //{ // if (caForm.IsNeedToRefresh) // { // this.GetOrders(); // } //}; //caForm.Show(); FBPage page = FBPage.GetPage(orderEntity); page.EditForm.OperationType = operationType; FrameworkElement plRoot = CommonFunction.ParentLayoutRoot; EntityBrowser eb = new EntityBrowser(page); eb.EntityScrollViewer.HorizontalScrollBarVisibility = ScrollBarVisibility.Auto; eb.Show <string>(DialogMode.Default, plRoot, "", (result) => { }); page.RefreshData += (o, e) => { this.GetOrders(); }; page.PageClosing += (o, e) => { eb.Close(); }; }
/// <summary> /// Initializes a new instance of the <see cref="UserDataRule"/> class. /// </summary> /// <param name="columnName">Name of the column.</param> /// <param name="propertyName">Name of the property.</param> /// <param name="appliesWhen">The rule can be applied to insert, update, and/or soft delete operations.</param> /// <exception cref="ArgumentOutOfRangeException">appliesWhen;appliesWhen may only be a combination of Insert, Update, or Delete</exception> /// <remarks>This will have no effect on hard deletes.</remarks> public UserDataRule(string columnName, string propertyName, OperationTypes appliesWhen) : base(columnName, appliesWhen) { if (appliesWhen.HasFlag(OperationTypes.Select)) throw new ArgumentOutOfRangeException("appliesWhen", appliesWhen, "appliesWhen may only be a combination of Insert, Update, or Delete"); PropertyName = propertyName; }
/// <summary> /// Sets the source property value. /// </summary> /// <param name="entity">The entity value.</param> /// <param name="value">The property value.</param> /// <param name="operationType">The single <see cref="Mapper.OperationTypes"/> being performed to enable selection.</param> protected void SetSrceValue(TSrce entity, TSrceProperty value, OperationTypes operationType) { if (OperationTypes.HasFlag(operationType)) { SrcePropertyInfo.SetValue(entity, value); } }
public Operator(string symbol, OperatorTypes type, int precedence, AssociativityTypes associativity, OperationTypes operationType) { this.Symbol = symbol; this.Type = type; this.Precedence = precedence; this.AssociativityType = associativity; this.OperationType = operationType; }
protected void SaveLogOperation(OperationTypes operation, object objectKey, object masterKey = null, string actionName = null) { if (Request.Form["hfContainer"].FirstOrDefault() != null) { var html = Request.Form["hfContainer"].FirstOrDefault(); SaveLogOperation(this.ControllerName?.ToLower(), actionName ?? this.ActionName, html, operation, objectKey, masterKey); } }
/// <summary> /// Initializes a new instance of the <see cref="UserDataRule" /> class. /// </summary> /// <param name="columnName">Name of the column.</param> /// <param name="kind">The kind.</param> /// <param name="appliesWhen">The rule can be applied to insert, update, and/or soft delete operations.</param> /// <exception cref="ArgumentOutOfRangeException">appliesWhen;appliesWhen may only be a combination of Insert, Update, or Delete</exception> /// <remarks> /// This will have no effect on hard deletes. /// </remarks> public DateTimeRule(string columnName, DateTimeKind kind, OperationTypes appliesWhen) : base(columnName, appliesWhen) { if (appliesWhen.HasFlag(OperationTypes.Select)) throw new ArgumentOutOfRangeException("appliesWhen", appliesWhen, "appliesWhen may only be a combination of Insert, Update, or Delete"); if (kind == DateTimeKind.Unspecified) throw new ArgumentOutOfRangeException("kind"); Kind = kind; }
public void CreateOperation(OperationTypes operationType, decimal deltaMoney) { // проверить доступ сотрудника // создать операцию // применить операцию }
/// <summary> /// Initializes a new instance of the <see cref="ColumnRule"/> class. /// </summary> /// <param name="columnName">Name of the column.</param> /// <param name="appliesWhen">The applies when.</param> /// <exception cref="ArgumentException"></exception> protected ColumnRule(string columnName, OperationTypes appliesWhen) : base(appliesWhen) { if (string.IsNullOrEmpty(columnName)) throw new ArgumentException($"{nameof(columnName)} is null or empty.", nameof(columnName)); ColumnName = columnName; }
public static SupportedFeatures GetSupportedFeaturesFor(OperationTypes type, int protocolVersion) { if (SupportedFeaturesByProtocol[type].TryGetValue(protocolVersion, out var features) == false) { throw new ArgumentException($"{type} in protocol {protocolVersion} was not found in the features set."); } return(features); }
public void CleanAll() { MyOperationType = OperationTypes.FirstOrDefault(); MyAccName = AvailableAccNames.FirstOrDefault(); Amount = null; MyCurrency = Currencies.FirstOrDefault(); MyTagPickerVm.Tags.Clear(); MyComment = ""; }
/// <summary> /// Initializes a new instance of the <see cref="UserDataRule"/> class. /// </summary> /// <param name="columnName">Name of the column.</param> /// <param name="propertyName">Name of the property.</param> /// <param name="appliesWhen">The rule can be applied to insert, update, and/or soft delete operations.</param> /// <exception cref="ArgumentOutOfRangeException">appliesWhen;appliesWhen may only be a combination of Insert, Update, or Delete</exception> /// <remarks>This will have no effect on hard deletes.</remarks> public UserDataRule(string columnName, string propertyName, OperationTypes appliesWhen) : base(columnName, appliesWhen) { if (appliesWhen.HasFlag(OperationTypes.Select)) { throw new ArgumentOutOfRangeException(nameof(appliesWhen), appliesWhen, "appliesWhen may only be a combination of Insert, Update, or Delete"); } PropertyName = propertyName; }
public MessageOperation(Id64 zone, Id64 message, Id64 operation, OperationTypes operationType, AddressDefinition address1, AddressDefinition address2, AddressDefinition address3, short isVirtual) : base(zone, Messages.RUN_TASK, message) { Operation = operation; OperationType = operationType; Address1 = address1; Address2 = address2; Address3 = address3; IsVirtual = isVirtual; }
public Employee(int number, string name, string password, OperationTypes allowedOperationTypes) : base(number, name) { IsSingIn = false; Password = password; AllowedOperationTypes = allowedOperationTypes; }
/// <summary> /// Initializes a new instance of the <see cref="ValueRule"/> class. /// </summary> /// <param name="columnName">Name of the column.</param> /// <param name="valueFactory">The value factory.</param> /// <param name="appliesWhen">The applies when.</param> /// <exception cref="ArgumentOutOfRangeException">appliesWhen;appliesWhen may only be a combination of Insert, Update, or Delete</exception> public ValueRule(string columnName, ColumnValueGenerator valueFactory, OperationTypes appliesWhen) : base(columnName, appliesWhen) { if (appliesWhen.HasFlag(OperationTypes.Select)) { throw new ArgumentOutOfRangeException(nameof(appliesWhen), appliesWhen, "appliesWhen may only be a combination of Insert, Update, or Delete"); } ValueFactory = valueFactory; }
/// <summary> /// Gets the source property value. /// </summary> /// <param name="entity">The entity value.</param> /// <param name="operationType">The single <see cref="Mapper.OperationTypes"/> being performed to enable selection.</param> /// <returns>The property value.</returns> protected TSrceProperty GetSrceValue(TSrce entity, OperationTypes operationType) { if (OperationTypes.HasFlag(operationType)) { return(SrcePropertyExpression.GetValue(entity)); } else { return(default);
public DiskSpaceRequirements(OperationTypes operation, Host host, string updateName, long requiredDiskSpace, long availableDiskSpace, long reclaimableDiskSpace) { Operation = operation; Host = host; UpdateName = updateName; RequiredDiskSpace = requiredDiskSpace; AvailableDiskSpace = availableDiskSpace; ReclaimableDiskSpace = reclaimableDiskSpace; }
/// <summary> /// Initializes a new instance of the <see cref="ColumnRule"/> class. /// </summary> /// <param name="columnName">Name of the column.</param> /// <param name="appliesWhen">The applies when.</param> /// <exception cref="ArgumentException"></exception> protected ColumnRule(string columnName, OperationTypes appliesWhen) : base(appliesWhen) { if (string.IsNullOrEmpty(columnName)) { throw new ArgumentException($"{nameof(columnName)} is null or empty.", nameof(columnName)); } ColumnName = columnName; }
public OperationTreeNode(OperationTypes operation, bool isRoot, List<LevelPropertyInfo> properties) { m_Properties = properties; item_ctrl = new OperationItemControl(operation, isRoot); Header = item_ctrl; item_ctrl.CustomCommandClick += new EventHandler<CustomItemEventArgs>(item_ctrl_CustomCommandClick); IsExpanded = true; }
/// <summary> /// Maps the source to the destination updating an existing object. /// </summary> /// <param name="sourceEntity">The source entity.</param> /// <param name="destinationEntity">The destination entity.</param> /// <param name="operationType">The single <see cref="Mapper.OperationTypes"/> being performed to enable selection.</param> public void MapToDest(TSrce sourceEntity, TDest destinationEntity, OperationTypes operationType = OperationTypes.Unspecified) { foreach (var map in Mappings) { map.MapToDest(sourceEntity, destinationEntity, operationType); } destinationEntity = OnMapToDest(sourceEntity, destinationEntity, operationType); }
public void InitControl(OperationTypes operationType) { columnHeaderStyle = (Style)Application.Current.Resources["DataGridColumnHeaderStyle"]; this.Style = (Style)Application.Current.Resources["DataGridStyle"]; this.RowStyle = (Style)Application.Current.Resources["DataGridRowStyle"]; //this.ColumnHeaderStyle = this.Columns.Clear(); for (int i = 0; i < GridItems.Count; i++) { DataGridColumn dgtc = GetDataGridColumn(GridItems[i]); string toolTipText = GridItems[i].TipText; dgtc.Header = GridItems[i].PropertyDisplayName; dgtc.Width = new DataGridLength(GridItems[i].Width); dgtc.SortMemberPath = GridItems[i].PropertyName; dgtc.CanUserSort = true; // 可写背景色 if (!GridItems[i].IsReadOnly && (operationType != OperationTypes.Browse && operationType != OperationTypes.Audit)) { dgtc.CellStyle = writtableStyle; dgtc.IsReadOnly = false; } else { dgtc.IsReadOnly = true; } this.Columns.Add(dgtc); var styleHeader = this.columnHeaderStyle; if (toolTipText != null) { //<TextBlock Margin="3 2 0 2" Foreground="{StaticResource HeaderBackgroundfontColor1}" x:Name="ContentFontColor"> //</TextBlock> XElementString gridXCs = new XElementString("TextBlock", new XAttributeString("Margin", "3 2 0 2"), new XAttributeString("Foreground", "{StaticResource HeaderBackgroundfontColor1}"), new XAttributeString("x:Name", "ContentFontColor"), new XAttributeString("Text", "{Binding Converter={StaticResource GridHeaderConverter}, RelativeSource={RelativeSource TemplatedParent}}"), new XAttributeString("ToolTipService.ToolTip", toolTipText) ); var dtHeadTextBlockTemplate = DataTemplateHelper.GetDataTemplate(gridXCs); styleHeader = styleHeader.Copy(); styleHeader.SetStyle(DataGridColumnHeader.ContentTemplateProperty, dtHeadTextBlockTemplate); } dgtc.HeaderStyle = styleHeader; } }
/// <summary> /// Initializes a new instance of the <see cref="SoftDeleteRule"/> class. /// </summary> /// <param name="columnName">Name of the column.</param> /// <param name="deletedValue">The value that represents a deleted row.</param> /// <param name="appliesWhen">The rule can be applied to delete and/or select operations.</param> /// <exception cref="ArgumentOutOfRangeException">appliesWhen;appliesWhen may only be Select or Delete</exception> public SoftDeleteRule(string columnName, object deletedValue, OperationTypes appliesWhen) : base(columnName, appliesWhen) { switch (appliesWhen) { case OperationTypes.Select: case OperationTypes.Delete: case OperationTypes.SelectOrDelete: break; default: throw new ArgumentOutOfRangeException("appliesWhen", appliesWhen, "appliesWhen may only be Select or Delete"); } DeletedValue = deletedValue; }
public CForm(OrderEntity source) { orderEntity = source; Type type = typeof(OrderSource<>).MakeGenericType(new Type[] { source.OrderType }); OrderSource = Activator.CreateInstance(type) as IOrderSource; if (string.IsNullOrEmpty(source.OrderID)) { OperationType = OperationTypes.New; this.GridToolBar_Delete.Visibility = Visibility.Collapsed; } else { OperationType = OperationTypes.Edit; } InitializeComponent(); List<string[]> FInfo = new List<string[]>(); FInfo.Add(new string[]{"单据编号", "OrderCode", "OrderCode", "0", "0"}); FInfo.Add(new string[] { "状态", "OrderStates", "OrderStates", "0", "0" }); FInfo.Add(new string[] { "创建人", "CreateUser", "CreateUser", "0", "0" }); FInfo.Add(new string[] { "创建时间", "CreateDate", "CreateDate", "0", "0" }); this.GForm.LeftFForm.Items = GetFieldItems(FInfo); this.GForm.LeftFForm.InitForm(); FInfo.Clear(); FInfo.Add(new string[] { "单据类型", "OrderType", "OrderType", "0", "0" }); FInfo.Add(new string[] { "申请人", "Applicant", "Applicant", "3", "1" }); FInfo.Add(new string[] { "申请部门", "AppliedDepartMent", "AppliedDepartMentData", "2", "1" }); FInfo.Add(new string[] { "申请公司", "Company", "CompanyData", "2", "1" }); this.GForm.RightForm.Items = GetFieldItems(FInfo); this.GForm.RightForm.InitForm(); FInfo.Clear(); FInfo.Add(new string[] { "备注", "Remark", "Remark", "4", "0" }); this.GFormRemark.Items = GetFieldItems(FInfo); this.GFormRemark.InitForm(); FInfo.Clear(); FInfo.Add(new string[] { "编号", "SerialNumber", "75", "1" }); FInfo.Add(new string[] { "预算项目", "ObjectName", "200", "1" }); FInfo.Add(new string[] { "可用金额", "UsableMoney", "100", "1" }); FInfo.Add(new string[] { "已用金额", "UsedMoney", "100", "0" }); FInfo.Add(new string[] { "费用类型", "ChargeType", "100", "1" }); this.AGrid.Items= GetDataGridItem(FInfo); this.AGrid.InitGrid(); BindingData(); }
public FilterOperationItemControl(OperationTypes operation) { Operation = operation; Text = operation.ToString(); switch (operation) { case OperationTypes.And: Icon = UriResources.Images.And16; break; case OperationTypes.Or: Icon = UriResources.Images.Or16; break; } }
/// <summary> /// Записывает "описание операции" в хранилище /// </summary> /// <param name="operationDescription">"описание операции"</param> public void Save(int argument1, int argument2, decimal operationResult, OperationTypes operationType) { var operationDescription = new OperationDescription { //аргумент 1 Argument1 = argument1, //аргумент 2 Argument2 = argument2, //тип операции OperationType = operationType, //результат операции OperationResult = operationResult, //время операции (проставляется текущее) OperationTime = dateTimeService.DateTimeNow() }; //сохраняем "описание операции" в хранилище this.Save(operationDescription); }
/// <summary> /// Initializes a new instance of the <see cref="ValidateWithNotifyDataErrorInfo"/> class. /// </summary> /// <param name="appliesWhen">The rule applies when.</param> /// <exception cref="ArgumentOutOfRangeException">appliesWhen;appliesWhen may only be a combination of Insert or Update</exception> public ValidateWithNotifyDataErrorInfo(OperationTypes appliesWhen) : base(appliesWhen) { if (appliesWhen.HasFlag(OperationTypes.Select) || appliesWhen.HasFlag(OperationTypes.Delete)) throw new ArgumentOutOfRangeException("appliesWhen", appliesWhen, "appliesWhen may only be a combination of Insert or Update"); }
public void InitControl(OperationTypes operationType) { }
private void ShowEditForm(OrderEntity orderEntity, OperationTypes operationType) { //OrderForm caForm = CommonFunction.GetOrderForm(orderEntity); //caForm.Width = this.ActualWidth; //caForm.Height = this.ActualHeight; //caForm.Closed += (o, e) => //{ // if (caForm.IsNeedToRefresh) // { // this.GetOrders(); // } //}; //caForm.Show(); FBPage page = FBPage.GetPage(orderEntity); page.EditForm.OperationType = operationType; FrameworkElement plRoot = CommonFunction.ParentLayoutRoot; EntityBrowser eb = new EntityBrowser(page); eb.EntityScrollViewer.HorizontalScrollBarVisibility = ScrollBarVisibility.Auto; eb.Show<string>(DialogMode.Default, plRoot, "", (result) => { }); page.RefreshData += (o, e) => { this.GetOrders(); }; page.PageClosing += (o, e) => { eb.Close(); }; }
public FilterOperation(OperationTypes operation) { Operation = operation; }
private void ShowEditForm(OrderEntity orderEntity, OperationTypes operationType) { FBPage page = FBPage.GetPage(orderEntity); page.EditForm.OperationType = operationType; FrameworkElement plRoot = CommonFunction.ParentLayoutRoot; EntityBrowser eb = new EntityBrowser(page); eb.Show<string>(DialogMode.Default, plRoot, "", (result) => { }); eb.MinWidth = 400; eb.MinHeight = 300; page.PageClosing += (o, e) => { eb.Close(); }; }
public void InitControl(OperationTypes operationType) { OperationType = operationType; IsReadOnly = !(OperationType == OperationTypes.Add || OperationType == OperationTypes.Edit); InitForm(); }
public void InitControl(OperationTypes operationType) { this.OperationType = operationType; //if (operationType == OperationTypes.Audit || operationType == OperationTypes.Browse) //{ //UploadControl.FileState = SMT.SaaS.FrameworkUI.FileUpload.Constants.FileStates.FileBrowse; //UploadControl.InitBtn(Visibility.Collapsed, Visibility.Collapsed); //模块编码,一般为表名 string ModelName = uploadInfo.ModelName; //动作 //OperationType formTypes = ;\ FormTypes formTypes = new FormTypes(); string ide = UploadID; switch (OperationType) { case OperationTypes.Add: formTypes = FormTypes.New; break; case OperationTypes.Edit: formTypes = FormTypes.Edit; break; case OperationTypes.ReSubmit: formTypes = FormTypes.Resubmit; break; case OperationTypes.Browse: formTypes = FormTypes.Browse; break; case OperationTypes.Audit: formTypes = FormTypes.Audit; break; } if (!string.IsNullOrEmpty(UploadID)) { //UploadControl.Load_fileData(, this);//获取相应的上传信息 InitFileLoad(ModelName, UploadID, formTypes, NewUploadControl, true); } //} else { //UploadControl.InitBtn(Visibility.Visible, Visibility.Collapsed);//隐藏删除、添加按钮 //UploadControl.EntityEditor = this;//查看、审核时初始化用来解决异步显示控件的问题 } }
/// <summary> /// Initializes a new instance of the <see cref="ValidationRule"/> class. /// </summary> /// <param name="appliesWhen">The rule applies when.</param> protected ValidationRule(OperationTypes appliesWhen) : base(appliesWhen) { }
/// <summary> /// Initializes a new instance of the <see cref="AuditRule"/> class. /// </summary> /// <param name="appliesWhen">The rule applies when.</param> protected AuditRule(OperationTypes appliesWhen) { AppliesWhen = appliesWhen; }
/// <summary> /// Validates an atomic instruction. /// </summary> /// <param name="programInternalForm">The program internal form.</param> /// <returns>The error encountered.</returns> protected ErrorTypes ValidateAtomic(List<PIFEntry> programInternalForm) { List<string> tokens = new List<string>(); string op = null; foreach (PIFEntry entry in programInternalForm) { if (entry.Code <= 1) { tokens.Add(entry.Code.ToString()); } else { tokens.Add(entry.Symbol); } if (entry.Symbol == "}") { return ErrorTypes.Invalid; } if (ScopeScanner.AssignmentOperators.Contains(entry.Symbol)) { op = entry.Symbol; break; } } if (!parser.ValidateExpression(tokens, opGrammar)) { return ErrorTypes.Invalid; } if (op == "+=") { opType = OperationTypes.Addition; } if (op == "-=") { opType = OperationTypes.Subtraction; } if (op == "++") { opType = OperationTypes.Increment; } if (op == "--") { opType = OperationTypes.Decrement; } StringBuilder variableBuilder = new StringBuilder(); int i = 0; while (programInternalForm[i].Symbol != op) { variableBuilder.Append(programInternalForm[i].Symbol); i++; } i++; variable = variableBuilder.ToString(); StringBuilder expressionBuilder = new StringBuilder(); while (programInternalForm[i].Symbol != ";" && programInternalForm[i].Symbol != ",") { expressionBuilder.Append(programInternalForm[i].Symbol); i++; } expression = expressionBuilder.ToString(); return ErrorTypes.Valid; }
private static OperationData FindOperation(OperationTypes type) { lock (_lockObject) { for (int i = 0; i < _allOperations.Count; ++i) { if (_allOperations[i].Type == type) return _allOperations[i]; } } return null; }
public OperationData(OperationTypes type) { Type = type; Count = 1; }
/// <summary> /// Initializes a new instance of the <see cref="RestrictColumn"/> class. /// </summary> /// <param name="columnName">Name of the column.</param> /// <param name="appliesWhen">While operations are being restricted.</param> /// <param name="exceptWhen">This function will return true if the rule doesn't apply to this user..</param> public RestrictColumn(string columnName, OperationTypes appliesWhen, ExceptWhenPredicate exceptWhen) : base(appliesWhen) { ColumnName = columnName; ExceptWhen = exceptWhen; }