public ActionResult CreateProductOperation(Int32 Id)
{
OperationManager operationManager = new OperationManager();
OperationModel newOperation = operationManager.CreateNewOperation(Id);
return(PartialView("CreateOperation", newOperation));
}
public static bool WithdrawMoney(string cardId, decimal amount)
{
var result = true;
using (var dbContext = new BankContext())
{
try
{
var serviceCard = dbContext.Cards.SingleOrDefault(c => c.CardId == ServiceCardId);
serviceCard.Balance += amount;
var card = dbContext.Cards.SingleOrDefault(c => c.CardId == cardId);
card.Balance -= amount;
var operation = new OperationModel
{
InId = ServiceCardId,
OutId = cardId,
Amount = amount,
InBalanceAfter = serviceCard.Balance,
OutBalanceAfter = card.Balance
};
dbContext.Operations.Add(operation);
dbContext.SaveChanges();
}
catch (Exception)
{
result = false;
}
}
return(result);
}
/// <summary>
/// 搜索页面修改代码数据
/// </summary>
/// <param name="Title"></param>
/// <param name="Code"></param>
/// <param name="Visible"></param>
/// <returns></returns>
public string ModifyCode(string Title, string Code, string Visible)
{
var data = CodeData.Where(x => x.Title == Title).Single();
if (code.ModifyData(new CodeModel {
fTable = "Code_tb", Visible = Visible, Title = Title, Code = Code, objectId = data.objectId
}))
{
data.Code = Code; data.Visible = Visible; data.Title = Title;
//添加修改记录--------------------
if (Visible == "Visible")
{
OperationModel operationModel = new OperationModel("OperationNews_tb");
operationModel.User = (string)SessionHelp.Get("UserName");
operationModel.Operate = "修改了";
operationModel.Title = Title;
List <string> PathKind = new List <string>();
string id;
id = KindData.Where(x => x.objectId == data.KindObjectId).Single().ParentId;
KindPath(id, ref PathKind);
operationModel.Kind = PathKind[PathKind.Count - 1];
operate.Create(operationModel);
}
//添加修改记录-------------------
return("修改成功");
}
return("修改失败");
}
public async Task <IEnumerable <object> > Execute(OperationModel model, CancellationToken token, object customeParameter)
{
return(await DebuggerSession.Instance.ExecuteOperation(() =>
{
var result = from r in DebuggerSession.Instance.Runtime.EnumerateMemoryRegions()
where r.Type != ClrMemoryRegionType.ReservedGCSegment
group r by r.Type.ToString() into g
let total = g.Sum(p => (uint)p.Size)
orderby total ascending
select new
{
TotalSize = total,
Count = g.Count().ToString(),
Type = g.Key
};
var list = result.ToList();
list.Add(new
{
TotalSize = result.Sum(item => item.TotalSize),
Count = "",
Type = "All"
});
return list;
}));
}
public async Task <IEnumerable <object> > Execute(OperationModel model, CancellationToken token, object customeParameter)
{
List <string> types = model.Types?.Split(';').ToList();
return(await DebuggerSession.Instance.ExecuteOperation(() =>
{
var generation = (int)customeParameter;
var heap = DebuggerSession.Instance.Heap;
var results = new List <object>();
foreach (var obj in heap.EnumerateObjectAddresses().Where(ptr => (generation != -1 && generation == heap.GetGeneration(ptr)) || generation == -1))
{
if (token.IsCancellationRequested)
{
break;
}
var type = heap.GetObjectType(obj);
if (type == null)
{
continue;
}
if (types?.Any(t => type.Name.ToLower().Contains(t.ToLower())) ?? true)
{
results.Add(new { Address = obj, Type = type.Name, Generation = heap.GetGeneration(obj), Size = type.GetSize(obj) });
}
}
return results;
}));
}
private static void SerializeOperation(
Utf8JsonWriter writer,
OperationModel operation)
{
writer.WriteStartObject();
writer.WriteString("name", operation.Name);
writer.WriteString("type", operation.Type.Name);
writer.WritePropertyName("arguments");
writer.WriteStartArray();
foreach (ArgumentModel argument in operation.Arguments)
{
SerializeArgument(writer, argument);
}
writer.WriteEndArray();
writer.WritePropertyName("parser");
SerializeResultParser(writer, operation.Parser);
writer.WriteEndObject();
}
public async Task <int> SaveOperationModel(OperationModel operationModel)
{
LoggingService.Trace("Querying OperationsDatabase.SaveOperationModel");
var databaseConnection = await GetDatabaseConnection <OperationDatabaseModel>().ConfigureAwait(false);
var dbLock = databaseConnection.GetConnection().Lock();
try
{
var operationDatabaseModel = OperationDatabaseModel.ToOperationDatabaseModel(operationModel);
var existingData = await GetOperationModel(operationModel.Id);
if (existingData != null)
{
operationDatabaseModel.IsHiddenLocally = existingData.IsHiddenLocally;
}
databaseConnection.GetConnection().InsertOrReplaceWithChildren(operationDatabaseModel);
return(0);
}
catch (Exception e)
{
LoggingService.Error(e, "Error Querying OperationsDatabase.SaveOperationModel");
return(1);
}
finally
{
dbLock.Dispose();
}
}
public AddOperation(int operationTypeId)
{
InitializeComponent();
this._repo = new Repo();
this.productList = new List <OperationProductModel>();
this.serviceList = new List <OperationServiceModel>();
this.operation = this.DataContext as OperationModel;
this.operation.OperationTypeId = operationTypeId;
cbOperationType.ItemsSource = this._repo.GetOperationTypes();
cbOperationType.DisplayMemberPath = "Name";
cbSalaryType.ItemsSource = this._repo.GetSalaryOperationTypes();
cbSalaryType.DisplayMemberPath = "Name";
cbBankAccount.ItemsSource = this._repo.GetBankAccounts(1);
cbBankAccount.DisplayMemberPath = "BankName";
cbSalaryCurrency.ItemsSource = this._repo.GetCurrencies();
cbSalaryCurrency.DisplayMemberPath = "Name";
cbConvertedCurrency.ItemsSource = this._repo.GetCurrencies();
cbConvertedCurrency.DisplayMemberPath = "Name";
cbBankOperationType.ItemsSource = this._repo.GetBankOperationTypes();
cbBankOperationType.DisplayMemberPath = "Name";
cbUtilities.ItemsSource = this._repo.GetUtilities();
cbUtilities.DisplayMemberPath = "Name";
}
public ActionResult Withdraw(OperationModel model)
{
var client = this.clientsService.GetClient(model.ClientId);
this.paymentService.Withdraw(client, model.Amount);
return(this.Json(true, JsonRequestBehavior.AllowGet));
}
public async Task <IEnumerable <object> > Execute(OperationModel model, CancellationToken token, object customeParameter)
{
List <string> types = model.Types?.Split(';').ToList();
return(await DebuggerSession.Instance.ExecuteOperation(() =>
{
var heap = DebuggerSession.Instance.Heap;
var enumerable = from o in heap.EnumerateObjectAddresses()
let type = heap.GetObjectType(o)
where type == null || types == null || types.Any(t => type.Name.Contains(t))
group o by type
into g
let size = g.Sum(o => (uint)g.Key.GetSize(o))
orderby size
select new
{
Name = g.Key.Name,
Size = size,
Count = g.Count()
};
var results = new List <object>();
foreach (var item in enumerable)
{
results.Add(item);
if (token.IsCancellationRequested)
{
break;
}
}
return results;
}));
}
private static void RegisterOperationModel(
IDocumentAnalyzerContext context,
DocumentNode document,
OperationDefinitionNode operationDefinition)
{
ComplexOutputTypeModel returnType =
context.Types.OfType <ComplexOutputTypeModel>()
.First(t => t.SelectionSet == operationDefinition.SelectionSet && t.IsInterface);
var parser = new ParserModel(
context.GetOrCreateName(
GetClassName(operationDefinition.Name !.Value, "ResultParser")),
operationDefinition,
returnType,
context.FieldParsers.Where(t => t.Operation == operationDefinition).ToList());
var operation = new OperationModel(
returnType.Name,
context.Schema.GetOperationType(operationDefinition.Operation),
document,
operationDefinition,
parser,
CreateOperationArguments(context, operationDefinition));
context.Register(operation);
}
public ActionResult Index()
{
var model = new OperationModel();
model.Operations = _operationService.GetAllOperationNames().Select(x => new { value = x, text = x });
return(View(model));
}
public StatisticalComparisonDecisionOperationJob(OperationModel operationModel,
TimeSpan throttle) : base(operationModel, throttle)
{
var model = (StatisticalComparisonDecisionOperationModel)operationModel.ResultCauserClone;
OperationParameters = IDEAHelpers.GetDecisionsParameters(model);
}
private void SetResources(string _userid, string _filePath, CancellationToken token)
{
OperationModel model = new OperationModel();
INetworkPrintersOperator objPrintOperator = new NetworkPrintersOperator();
INetworkSharesOperator objNetworkOperator = new NetworkSharesOperator();
try
{
model = FileOperations.Read(_filePath);
OnNetworkPrintersRestoreStart?.Invoke(this, new StringEventArgs("Printers restore initiated"));
objPrintOperator.OnStateChange += NetworkPrintersOperator_OnStateChange;
objPrintOperator.OnStateError += NetworkPrintersOperator_OnStateError;
objPrintOperator.SetMappedPrinters(model, token);
OnNetworkPrintersRestoreCompleted?.Invoke(this, new StringEventArgs("Printers restore completed"));
OnNetworkSharesRestoreStart?.Invoke(this, new StringEventArgs("Network shares restore initiated"));
objNetworkOperator.OnStateChange += NetworkSharesOperator_OnStateChange;
objNetworkOperator.SetNetworkShares(model, token);
OnNetworkSharesRestoreCompleted?.Invoke(this, new StringEventArgs("Network shares restore completed"));
}
catch (Exception)
{
throw;
}
}
public async Task <IEnumerable <object> > Execute(OperationModel model, CancellationToken token, object customeParameter)
{
return(await DebuggerSession.Instance.ExecuteOperation(() =>
{
var runtime = DebuggerSession.Instance.Runtime;
var infoModel = new TargetProcessInfoOperationModel();
infoModel.AppDomains = string.Concat(runtime.AppDomains.Select(ad => ad.Name + ", ")).TrimEnd();
infoModel.AppDomains = infoModel.AppDomains.Remove(infoModel.AppDomains.Length - 1, 1);
infoModel.AppDomainsCount = runtime.AppDomains.Count;
infoModel.ThreadsCount = runtime.Threads.Count;
infoModel.ModulesCount = runtime.AppDomains.Sum(appDomain => appDomain.Modules.Count);
infoModel.SymbolPath = runtime.DataTarget.SymbolLocator.SymbolPath;
infoModel.ClrVersions = string.Concat(runtime.DataTarget.ClrVersions.Select(clrVer => clrVer.Version + ", ")).TrimEnd();
infoModel.ClrVersions = infoModel.ClrVersions.Remove(infoModel.ClrVersions.Length - 1, 1);
infoModel.DacInfo = string.Concat(runtime.DataTarget.ClrVersions.Select(ver => ver.DacInfo.FileName + ", ")).TrimEnd();
infoModel.DacInfo = infoModel.DacInfo.Remove(infoModel.DacInfo.Length - 1, 1);
infoModel.Architecture = runtime.DataTarget.Architecture.ToString();
infoModel.IsGcServer = runtime.ServerGC;
infoModel.HeapCount = runtime.HeapCount;
infoModel.DumpCreatedTime = DebuggerSession.Instance.AttachedTime.ToShortTimeString();
infoModel.PointerSize = runtime.PointerSize;
var enumerable = from prop in infoModel.GetType().GetProperties()
select new { Name = prop.Name, Value = prop.GetValue(infoModel) };
return enumerable.ToList();
}));
}
public ActionResult Exec(OperationModel model)
{
var sw = new Stopwatch();
model.Operations = calc.GetOpers().Select(o => new SelectListItem()
{
Text = $"{o.Name}", Value = $"{o.Name}"
});
sw.Start();
model.Result = calc.Exec(model.Operation, model.Args.ToArray());
sw.Stop();
#region Save
if (User.Identity.IsAuthenticated)
{
var item = new HistoryItem();
item.Args = string.Join(" ", model.Args);
item.Operation = OperationRepository
.GetAll($"[Name] = N'{model.Operation}'")
.FirstOrDefault()
.Id;
item.Result = model.Result;
item.ExecDate = DateTime.Now;
item.Author = UserRepository.GetByName(User.Identity.Name);
item.TimeCalculation = sw.ElapsedMilliseconds;
HistoryRepository.Save(item);
}
#endregion
return(Json(new { model.Result }));
}
public ActionResult CreateProductOperation(Int32?Id)
{
OperationModel newOperation = new OperationModel();
newOperation._IdProduct = Id.Value;
return(PartialView("CreateOperation", newOperation));
}
internal OperationSecureModel(
OperationModel operationModel,
OperationModelStereotypeExtensions.Secured stereotype)
{
OperationModel = operationModel;
Stereotype = stereotype;
}
public ActionResult <ApiResponse <OperationModel> > CreateOperation([FromBody] CreateOperationModel model)
{
try
{
if (string.IsNullOrWhiteSpace(model.Name))
{
return(Json(ApiResponse <OperationModel> .WithError("Name is required")));
}
var onlineUser = this._userService.GetOnlineUser(this.HttpContext);
if (onlineUser == null)
{
return(Json(ApiResponse.WithError("Not Authority")));
}
OperationModel result = null;
var newOperation = new Operation();
newOperation.Name = model.Name;
newOperation.MissionId = Convert.ToInt32(model.MissionId);
newOperation.OperationStatus = 0;
this._operationService.AddNewOperation(newOperation);
result = _operationService.GetByOperationId(newOperation.Id);
return(Json(ApiResponse <OperationModel> .WithSuccess(result)));
}
catch (Exception exp)
{
return(Json(ApiResponse <OperationModel> .WithError(exp.ToString())));
}
}
public async void Operations(OperationType type, Double[] values, Double result)
{
OperationModel data = new OperationModel
{
Type = type,
Value = values,
};
using (HttpClient client = Client)
{
using (HttpResponseMessage response = await client.PostAsync($"{Version}/operations",
data.ToStringContent()))
{
response.EnsureSuccessStatusCode();
String content = await response.Content.ReadAsStringAsync();
Assert.False(String.IsNullOrEmpty(content));
OperationModel operation = JsonConvert.DeserializeObject <OperationModel>(content);
Assert.NotNull(operation);
Assert.NotNull(Context.Operations);
Assert.NotEmpty(Context.Operations);
Assert.Single(Context.Operations, (e) => { return(e.Id == operation.Id); });
Assert.Equal(data.Type, operation.Type);
Assert.Equal(data.Value, operation.Value);
Assert.Equal(result, operation.Result);
}
}
}
public async Task <IActionResult> PutProductCategorie([FromRoute] Guid Id, [FromBody] OperationModel obj)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (Id != obj.Id)
{
return(BadRequest());
}
var dataModel = _mapper.Map <Operation>(obj);
_context.Entry(dataModel).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!Exists(Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
/// <summary>
/// The CreateDummyOperations.
/// </summary>
/// <param name="operations">The operations<see cref="ObservableCollection{OperationModel}"/>.</param>
/// <param name="pauseDownloadAction">The pauseDownloadAction<see cref="ICommand"/>.</param>
private void CreateDummyOperations(ObservableCollection <DownloadItemModel> operations, Action <DownloadItemModel> pauseDownloadAction)
{
var random = new Random();
for (var i = 0; i < 10; i++)
{
var operation = new DummyOperation()
{
Status = (OperationStatus)(i % 6)
};
var operationModel = new OperationModel(operation)
{
PauseDownloadAction = pauseDownloadAction, IsQueuedControlsVisible = (i & 1) == 1
};
var progress = TestHelper.GetRandomLong(0, 100);
operation.Duration = TestHelper.GetRandomLong(10, 10000);
operation.FileSize = TestHelper.GetRandomLong(10000, 10000000000);
operation.Input = $"https://youtube.com/view={i}";
operation.Link = $"https://youtube.com/link={i}";;
operation.Output = $@"C:\Users\YoutubeUser\File{TestHelper.GetRandomLong(100, 10000)}.mp4";
operation.Progress = progress;
operation.ProgressPercentage = (int)progress;
operation.ProgressText = $"{progress}%";
operation.ReportsProgress = true;
operation.Speed = $"{TestHelper.GetRandomInt(10, 100)}MB/s";
operation.Status = (OperationStatus)(i % 6);
operation.Thumbnail = null;
operation.Title = $"Youtube Title Movie Number {i}";
operations.Add(operationModel);
}
}
public void ContainsTest()
{
var operation1 = new DummyOperation
{
Output = "NewVideo1.mp4"
};
var operation2 = new DummyOperation
{
Output = "NewVideo2.mp4"
};
var operation3 = new DummyOperation
{
Output = "NewVideo1.mp4"
};
var model1 = new OperationModel(operation1);
var model2 = new OperationModel(operation2);
var model3 = new OperationModel(operation3);
var models = new ObservableCollection <OperationModel>
{
model1,
model2
};
models.Contains(model1).Should().BeTrue();
models.Contains(model2).Should().BeTrue();
models.Contains(model3).Should().BeTrue();
}
public virtual ActionResult Details(string loanNumber, string operationNumber, bool displayAsGroup)
{
OperationModel operationModel = client.GetParentOperation(new OperationModel()
{
OperationId = -1, OperationNumber = operationNumber.Trim()
});
ViewData["userId"] = IDBContext.Current.UserName;
ViewData["operationNumber"] = operationModel.OperationNumber;
ViewData["loanNumber"] = loanNumber;
ViewData["displayAsGroup"] = displayAsGroup;
LoanExpenseCategoryModel loanExpenseModel = ClientLoan.GetDetailLoanData(IDBContext.Current.UserName, operationNumber, loanNumber);
loanExpenseModel.Loan.LoanStage = masterData.GetMasterDataNameByCode("LOAN_STATUS", loanExpenseModel.Loan.LoanStage, IDBContext.Current.CurrentLanguage);
ViewBag.LoanStatusList = masterData.GetMasterDataModels("LOAN_STATUS"); //LOAN_STATUS
var PartialEligibility = ClientLoan.GetMinElegibilityDateByLoans(operationNumber);
ViewBag.PartialEligibility = string.Empty;
if (PartialEligibility.HasValue)
{
ViewBag.PartialEligibility = string.Format("{0:dd MMM yyyy}", PartialEligibility.Value);
}
return(View(loanExpenseModel));
}
private OperationModel GetResourcesBackup(string _userid, List <string> custompaths, string _backupPath, CancellationToken token)
{
OperationModel valResults = new OperationModel();
//OperationModel _valResults = new OperationModel();
INetworkPrintersOperator objPrintOperator = new NetworkPrintersOperator();
INetworkSharesOperator objNetworkOperator = new NetworkSharesOperator();
objNetworkOperator.OnAtomicStateChange += ObjNetworkOperator_OnAtomicStateChange;
objPrintOperator.OnAtomicStateChange += ObjPrintOperator_OnAtomicStateChange;
if (custompaths.Count > 0)
{
valResults.CustomPaths = new List <string>();
valResults.CustomPaths.AddRange(custompaths);
}
try
{
RegistryAccessValidation validate = new RegistryAccessValidation();
valResults.SID = validate.GetSID(_userid);
OnNetworkSharesBackupStart?.Invoke(this, new StringEventArgs("Network Backup Started"));
if (Environment.UserName.Equals(_userid))
{
valResults.NetworkSharesWMI = objNetworkOperator.GetNetworkSharesWMI(token);
}
else
{
valResults.NetworkShares = objNetworkOperator.GetNetworkShares($@"{valResults.SID}\Network", token);
}
OnNetworkSharesBackupCompleted?.Invoke(this, new StringEventArgs("Network Backup Completed"));
OnNetworkPrintersBackupStart?.Invoke(this, new StringEventArgs("Printers Backup Started"));
if (Environment.UserName.Equals(_userid))
{
valResults.NetworkPrintersWMI = objPrintOperator.GetMappedPrintersWMI(token);
}
else
{
valResults.NetworkPrinters = objPrintOperator.GetMappedPrinters($@"{valResults.SID}\Printers\Connections", token);
}
OnNetworkPrintersBackupCompleted?.Invoke(this, new StringEventArgs("Printers Backup Completed"));
string _backupjson = JsonConvert.SerializeObject(valResults);
FileOperations.Write(_backupPath, valResults);
//_valResults = FileOperations.Read(_backupPath);
}
catch (OperationCanceledException)
{
throw;
}
catch (Exception)
{
throw;
}
return(valResults);
}
private string GetReturnType(OperationModel operation)
{
if (operation.ReturnType == null)
{
return("ResponseEntity<Void>");
}
return($"ResponseEntity<{this.GetTypeAsObject(operation.TypeReference)}>");
}
public string EmitOperationReturnType(OperationModel o)
{
if (o.ReturnType == null)
{
return(o.IsAsync() ? "async Task" : "void");
}
return(o.IsAsync() ? $"async Task<{GetTypeName(o.ReturnType)}>" : GetTypeName(o.ReturnType));
}
private string GetOperationReturnType(OperationModel o)
{
if (o.TypeReference.Element == null)
{
return(o.IsAsync() ? "async Task" : "void");
}
return(o.IsAsync() ? $"async Task<{GetTypeName(o.TypeReference)}>" : GetTypeName(o.TypeReference));
}
private string GetOperationCallParameters(OperationModel o)
{
if (!o.Parameters.Any())
{
return("");
}
return(o.Parameters.Select(x => $"{x.Name}").Aggregate((x, y) => x + ", " + y));
}
private string GetOperationDefinitionParameters(OperationModel o)
{
if (!o.Parameters.Any())
{
return("");
}
return(o.Parameters.Select(x => $"{GetTypeName(x.TypeReference)} {x.Name}").Aggregate((x, y) => x + ", " + y));
}
public static Operation FromModel(OperationModel model)
{
return new Operation() { Op1 = model.Op1, Op2 = model.Op2, Result = model.Result
};
}
