public async Task CallAtlasApiAsync(Message message, ProcessType processType)
{
var token = await _tokenProvider.GetBearerTokenAsync("AtlasApiOAuth2");
_client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);
var requestUri = new Uri(message.CompanyId != null ? processType.EndPoint.Replace("{company}", message.CompanyId, StringComparison.InvariantCultureIgnoreCase) : processType.EndPoint);
//string json = JsonConvert.SerializeObject(message, Formatting.Indented, new JsonSerializerSettings
//{
// ContractResolver = new Newtonsoft.Json.Serialization.CamelCasePropertyNamesContractResolver()
//});
string json = message.Content;
HttpRequestMessage requestMessage = new HttpRequestMessage
{
Method = new HttpMethod(processType.Verb),
RequestUri = requestUri,
Content = new StringContent(json, Encoding.UTF8, "application/json")
};
_logger.LogInformation($"Calling Atlas API {requestUri.ToString()}.");
var response = await _client.SendAsync(requestMessage);
if (!response.IsSuccessStatusCode)
{
var content = await response.Content.ReadAsStringAsync();
_logger.LogError("Calling Atlas API failed with status code {Atlas_HttpResponseStatusCode} and content {Atlas_HttpResponseContent}.", response.StatusCode, content);
throw new Exception(content);
}
}
public void ChangeScene(ProcessType type)
{
mCurrentProcess.SceneEnd();
switch (type)
{
case ProcessType.Battle:
mCurrentProcess = mProcessBattle;
break;
case ProcessType.CardDetail:
mCurrentProcess = mProcessCardDetail;
break;
case ProcessType.CardSelect:
mCurrentProcess = mProcessCardSelect;
break;
case ProcessType.Loading:
mCurrentProcess = mProcessLoading;
break;
case ProcessType.Dump:
mCurrentProcess = mProcessDump;
break;
}
mCurrentProcess.SceneStart();
}
public Process(string name, ProcessType type)
{
this.Name = name;
this.Type = type;
this.ID = 0;
Running = false;
}
//Change the process type
public void SetHandleProcess(ProcessType newType)
{
// The process has changed
if (newType != m_processType)
{
if (m_instancedHandles != null)
{
Destroy(m_instancedHandles);
}
// Display Handles
switch (newType)
{
case ProcessType.Translate:
m_instancedHandles = Instantiate(m_translateHandles, transform.position, transform.rotation) as GameObject;
m_instancedHandles.transform.SetParent(transform);
break;
case ProcessType.Rotate:
m_instancedHandles = Instantiate(m_rotateHandles, transform.position, transform.rotation) as GameObject;
m_instancedHandles.transform.SetParent(transform);
break;
}
m_instancedHandles.transform.localScale = m_colourView.transform.localScale;
m_processType = newType;
}
}
public Common(ProcessType processType, int pollingInterval, int timeout, int responseTimeout)
{
_processType = processType;
_pollingInterval = pollingInterval;
_responseTimeout = responseTimeout;
Timeout = timeout;
}
public void Initialise(ProductType product, int delayModifier)
{
Product = product;
recipe = IngredientDataLookupManager.Instance.GetRecipeForProductType(Product);
int counter = 0;
foreach (var rd in recipe.RequiredIngredients)
{
IngredientType ingredient = rd.Item1;
ProcessType process = rd.Item2;
ingredientImages[counter].sprite = IngredientDataLookupManager.Instance.GetSpriteForIngredient(ingredient);
if (process != ProcessType.NONE && process != ProcessType.GARBAGE)
{
processImages[counter].enabled = true;
processImages[counter].sprite = IngredientDataLookupManager.Instance.GetSpriteForProcess(process);
}
else
{
processImages[counter].enabled = false;
}
counter++;
}
GameObject prefab = IngredientDataLookupManager.Instance.GetPrefabForProductType(Product);
GameObject spawned = Instantiate(prefab, finalProductPreviewParent);
spawned.transform.localScale = Vector3.one * finalProductScale;
spawned.transform.rotation = Quaternion.Euler(finalProductRotation);
SetLayerRecursively(spawned, LayerMask.NameToLayer("UI"));
}
public Process()
{
FlowElements = new FlowElementCollection(this);
this.processType = ProcessType.None;
this.isClosed = false;
this.isExecutable = false;
}
public DataSource(ProcessType processType, string serviceUrl, int pollingInterval, int timeout, int postPollingInterval, int responseTimeout, int ontogratorTab)
: base(processType, pollingInterval, timeout, responseTimeout)
{
PostPollingInterval = postPollingInterval;
_serviceUrl = serviceUrl;
_ontogratorTab = ontogratorTab;
}
public void SettingPagePesmission(Page page, ProcessType type)
{
CurrentType = type;
string enableControl = type.ToString();
foreach (Control control in page.Form.Controls)
{
if (control is WebControl)
{
if (((WebControl)control).Attributes[enableControl] != null)
{
SetControlStatus(control, ((WebControl)control).Attributes[enableControl]);
//control.Visible = false;
}
else
{
if (control.HasControls())
{
SettingControlPesmission(control);
}
}
}
else
{
if (control.HasControls())
{
SettingControlPesmission(control);
}
}
}
}
public TestComponent(ProcessType processTypeIn, TestComponentSocket socketIn, bool readOn, bool writeOn, bool exportOn)
{
if (processTypeIn == ProcessType.NULL || socketIn == null)
{
Debug.WriteLine("TestComponent > INVALID CONSTRUCTOR PARAMS"); return;
}
socket = socketIn;
processType = processTypeIn;
processHandler = new ProcessHandler(processType);
InitializeComponent();
loadLogo(processType);
if (!readOn)
{
readButton.Visibility = Visibility.Hidden;
}
if (!writeOn)
{
writeButton.Visibility = Visibility.Hidden;
}
if (!exportOn)
{
exportButton.Visibility = Visibility.Hidden;
}
}
/// <summary>
/// Constructs a new instance of the bus
/// </summary>
/// <param name="source">The process declaration</param>
/// <param name="process">The resolved process definition</param>
/// <param name="type">The process type</param>
public Process(AST.InstanceDeclaration source, AST.Process process, ProcessType type)
{
Source = source ?? throw new ArgumentNullException(nameof(source));
ProcessDefinition = process ?? throw new ArgumentNullException(nameof(process));
Type = type;
Statements = ProcessDefinition.Statements.Select(x => x.Clone()).ToArray();
}
/// <summary>
/// Unregister an app install's push notification registration.
/// This includes removing the registration table entry and removing it from the notification hub service.
/// </summary>
/// <param name="processType">not needed (ignored)</param>
/// <param name="userHandle">uniquely identifies the user</param>
/// <param name="appHandle">uniquely identifies the app</param>
/// <param name="pushRegistrationFeedEntity">Push registration table entry</param>
/// <returns>Delete registration task</returns>
public async Task DeleteRegistration(
ProcessType processType,
string userHandle,
string appHandle,
IPushRegistrationFeedEntity pushRegistrationFeedEntity)
{
// check inputs
if (string.IsNullOrWhiteSpace(userHandle))
{
this.log.LogException("got empty user handle");
}
if (string.IsNullOrWhiteSpace(appHandle))
{
this.log.LogException("got empty app handle");
}
// get the push notification hub interface for this app
IPushNotificationsHub pushNotificationsHub = await this.GetPushNotificationsHub(pushRegistrationFeedEntity.PlatformType, appHandle);
if (pushNotificationsHub == null)
{
this.log.LogException("did not find push notification hub for this app:" + appHandle);
}
// delete from the hub first, then delete from the table
await pushNotificationsHub.DeleteRegistration(pushRegistrationFeedEntity.HubRegistrationId);
await this.pushRegistrationsStore.DeletePushRegistration(
StorageConsistencyMode.Strong,
userHandle,
appHandle,
pushRegistrationFeedEntity.OSRegistrationId);
}
internal override void VisitProcess(Process process, ProcessType pipCategory)
{
string friendlyQualifier = Context.QualifierTable.GetCanonicalDisplayString(process.Provenance.QualifierId);
switch (pipCategory)
{
case ProcessType.XUnit:
WriteXunitDiscoverPackage();
ExtractOutputPathFromUnitTest(process, friendlyQualifier, 1);
break;
case ProcessType.VsTest:
ExtractOutputPathFromUnitTest(process, friendlyQualifier, 0);
break;
case ProcessType.Csc:
Project project = CreateProject(process);
// For now, if there is another csc process from the same spec file, ignore it.
if (ProjectsByQualifier.Count == 0)
{
ProjectsByQualifier[friendlyQualifier] = project;
PopulatePropertiesAndItems(project, process);
}
break;
case ProcessType.ResGen:
ExtractResourceFromResGen(process, friendlyQualifier);
break;
}
}
/// <summary>
/// Delete user profile
/// </summary>
/// <param name="processType">Process type</param>
/// <param name="userHandle">User handle</param>
/// <param name="appHandle">App handle</param>
/// <returns>Delete user task</returns>
public async Task DeleteUserProfile(
ProcessType processType,
string userHandle,
string appHandle)
{
await this.usersStore.DeleteUserProfile(StorageConsistencyMode.Strong, userHandle, appHandle);
var appFeedEntities = await this.ReadUserApps(userHandle);
if (appFeedEntities.Count == 0)
{
var linkedAccountFeedEntities = await this.ReadLinkedAccounts(userHandle);
foreach (var linkedAccountFeedEntity in linkedAccountFeedEntities)
{
await this.DeleteLinkedAccount(processType, userHandle, linkedAccountFeedEntity.IdentityProviderType, linkedAccountFeedEntity.AccountId);
}
}
await this.searchQueue.SendSearchRemoveUserMessage(userHandle, appHandle);
await this.popularUsersManager.DeletePopularUser(processType, userHandle, appHandle);
await this.pushNotificationsManager.DeleteUserRegistrations(processType, userHandle, appHandle);
}
public void Process(ProcessType processType)
{
int successCount = 0;
IList <string> files;
switch (processType)
{
case ProcessType.File:
files = this.options.File;
break;
case ProcessType.Directory:
var searchOption = this.options.IsRecursive
? SearchOption.AllDirectories
: SearchOption.TopDirectoryOnly;
files = (File.GetAttributes(this.options.Directory).HasFlag(FileAttributes.Directory))
? Directory.GetFiles(this.options.Directory, "*.xaml", searchOption).ToList()
: new List <string>();
break;
default:
throw new ArgumentException("Invalid ProcessType");
}
foreach (string file in files)
{
if (this.TryProcessFile(file))
{
successCount++;
}
}
this.Log($"Processed {successCount} of {files.Count} files.", LogLevel.Minimal);
}
/// <summary>
/// Categorizes a process
/// </summary>
public static ProcessWithType Categorize(Context context, Process process)
{
ProcessType type = ProcessType.None;
var stringTable = context.StringTable;
var toolName = process.GetToolName(context.PathTable);
if (toolName.CaseInsensitiveEquals(stringTable, context.CscExeName))
{
type = ProcessType.Csc;
}
else if (toolName.CaseInsensitiveEquals(stringTable, context.VsTestExeName))
{
type = ProcessType.VsTest;
}
else if (toolName.CaseInsensitiveEquals(stringTable, context.ResgenExeName))
{
type = ProcessType.ResGen;
}
else if (toolName.CaseInsensitiveEquals(stringTable, context.ClExeName))
{
type = ProcessType.Cl;
}
else if (toolName.CaseInsensitiveEquals(stringTable, context.LinkExeName))
{
type = ProcessType.Link;
}
return(new ProcessWithType(type, process));
}
void OnGUI()
{
_blocker.OnGUIStart();
if (GUILayout.Button("Find Scripts"))
{
foreach (var a in Pipeline.GetAssets("t:Script"))
{
Debug.Log("Script: " + a.name);
}
}
EditorGUILayout.LabelField("Process Settings");
_scriptNameContains = EditorGUILayout.TextField("Script name contains: ", _scriptNameContains);
_abortOnScript = EditorGUILayout.TextField("Abort on this script: ", _abortOnScript);
_processType = (ProcessType)EditorGUILayout.EnumPopup("Process type:", _processType);
if (_processType == ProcessType.ASYNC)
{
_allowCancel = EditorGUILayout.Toggle("Allow async cancel?", _allowCancel);
_tickTime = EditorGUILayout.Slider("Max time per operation:", _tickTime, 0.0001f, 0.1f);
}
if (GUILayout.Button("Process Scripts (dummy)"))
{
StartProcess();
}
_blocker.OnGUIEnd();
_guiProgress.Draw();
}
public static void findProcess2(Process process, String processName, ProcessType processType)
{
if (processName == null)
{
return;
}
//if (process_current != null) return;
Console.WriteLine("DEBUG > Searching process: " + processName);
process = Process.GetProcessesByName(processName).FirstOrDefault();
if (process == null)
{
return;
}
ProcessModule mainModule = process.MainModule;
Console.WriteLine("DEBUG > Found process: " + process.ProcessName);
Console.WriteLine("DEBUG > Found process's main module: " + mainModule);
if (mainModule != null)
{
long mainModuleAddress = process.MainModule.BaseAddress.ToInt64();
Console.WriteLine("DEBUG > Found process's Base address: " + mainModuleAddress + " / 0x" + mainModuleAddress.ToString("X12"));
}
process_current = process;
process_current_Type = processType;
}
/// <summary> Obtains company's process types</summary>
/// <param name="company">Company to search process types</param>
/// <returns>List of company's process types</returns>
private string ProccessTypeList(Company company)
{
var processTypeList = new StringBuilder("[");
bool firstProcessType = true;
foreach (var processType in ProcessType.ObtainByCompany(company.Id, this.dictionary))
{
if (processType.Active)
{
if (firstProcessType)
{
firstProcessType = false;
}
else
{
processTypeList.Append(",");
}
processTypeList.Append(Environment.NewLine).Append(" ").Append(processType.Json);
}
}
processTypeList.Append(Environment.NewLine).Append("]");
return(processTypeList.ToString());
}
/// <summary>
/// Process message
/// </summary>
/// <param name="message">Queue message</param>
/// <returns>Process message task</returns>
protected override async Task Process(IMessage message)
{
if (message is LikeMessage)
{
LikeMessage likeMessage = message as LikeMessage;
ProcessType processType = ProcessType.Backend;
if (likeMessage.DequeueCount > 1)
{
processType = ProcessType.BackendRetry;
}
var likeLookupEntity = await this.likesManager.ReadLike(likeMessage.ContentHandle, likeMessage.UserHandle);
if (likeLookupEntity != null && likeLookupEntity.LastUpdatedTime > likeMessage.LastUpdatedTime)
{
return;
}
await this.likesManager.UpdateLike(
processType,
likeMessage.LikeHandle,
likeMessage.ContentType,
likeMessage.ContentHandle,
likeMessage.UserHandle,
likeMessage.Liked,
likeMessage.ContentPublisherType,
likeMessage.ContentUserHandle,
likeMessage.ContentCreatedTime,
likeMessage.AppHandle,
likeMessage.LastUpdatedTime,
likeLookupEntity);
}
}
public object Handle(Mode modePrePost, ProcessType processType, object model, Db db)
{
if (modePrePost == Mode.Pre)
{
switch (processType)
{
case ProcessType.Add:
StatusFieldUpdate(model);
break;
case ProcessType.Update:
StatusFieldUpdate(model);
break;
case ProcessType.Delete:
break;
case ProcessType.Get:
break;
default:
break;
}
}
return(model);
}
/// <summary>
/// Create user linked account and profile
/// </summary>
/// <param name="processType">Process type</param>
/// <param name="userHandle">User handle</param>
/// <param name="identityProviderType">Identity provider type</param>
/// <param name="accountId">Account id</param>
/// <param name="appHandle">App handle</param>
/// <param name="firstName">First name</param>
/// <param name="lastName">Last name</param>
/// <param name="bio">User bio</param>
/// <param name="photoHandle">Photo handle</param>
/// <param name="createdTime">Created time</param>
/// <param name="requestId">Request id</param>
/// <returns>Create user task</returns>
public async Task CreateUserAndUserProfile(
ProcessType processType,
string userHandle,
IdentityProviderType identityProviderType,
string accountId,
string appHandle,
string firstName,
string lastName,
string bio,
string photoHandle,
DateTime createdTime,
string requestId)
{
await this.usersStore.InsertUser(
StorageConsistencyMode.Strong,
userHandle,
identityProviderType,
accountId,
appHandle,
firstName,
lastName,
bio,
photoHandle,
UserVisibilityStatus.Public,
createdTime,
requestId);
await this.usersStore.InsertLinkedAccountIndex(
StorageConsistencyMode.Strong,
userHandle,
identityProviderType,
accountId);
await this.searchQueue.SendSearchIndexUserMessage(userHandle, appHandle, createdTime);
}
public async Task <PurchaseResult> PurchaseUpgrade(string userId, ProcessType process)
{
await Task.Delay(MockLag);
UserData user;
PurchaseResult result = new PurchaseResult();
if ((int)process < (int)ProcessType.COUNT && (int)process >= 0)
{
result.processType = process;
if (userData.TryGetValue(userId, out user))
{
int level = user.processData[(int)process].level;
if (level < configData.configData[(int)process].levels.Length - 1)
{
long cost = configData.configData[(int)process].levels[level + 1].cost;
if (user.cookieCount >= cost)
{
user.cookieCount -= cost;
++user.processData[(int)process].level;
}
}
result.buildingCount = user.processData[(int)process].count;
result.cookieCount = user.cookieCount;
}
}
return(result);
}
public static ReviewProcess Start(string fileName, string arguments, ProcessType processType = ProcessType.Other)
{
var proc = new ReviewProcess(fileName, arguments, processType);
proc.Start();
return(proc);
}
private void SetInitialProcessType(ProcessType processType)
{
if (Name.Split('|').Count() <= 1)
{
Name = string.Format("{0}|{1}", EnumToString(processType), Name);
}
}
/// <summary>
/// Inicia um processo com um intervalo de tempo especificado e sincronizado com o objeto SynchronizedLock
/// </summary>
private void startProcess(int ms, ProcessType processType, Action del, bool sleepFirst = true)
{
while (true)
{
if (!sleepFirst)
{
lock (SynchronizedLock)
del.Invoke();
}
try
{
Thread.Sleep(ms);
}
catch (Exception ex)
{
_log.error(ex, processType);
}
if (sleepFirst)
{
lock (SynchronizedLock)
del.Invoke();
}
}
}
public BrowserCommandResult <bool> CreateProcess(string name, ProcessType type, string entity, int thinkTime = Constants.DefaultThinkTime)
{
Browser.ThinkTime(thinkTime);
return(this.Execute(GetOptions("Create Process"), driver =>
{
SwitchToDialogFrame();
driver.ClickWhenAvailable(By.XPath(Elements.Xpath[Reference.Process.Name]))
.SendKeys(name);
SetValue(new OptionSet()
{
Name = Elements.ElementId[Reference.Process.Category], Value = type.ToString()
});
SetValue(new OptionSet()
{
Name = Elements.ElementId[Reference.Process.Entity], Value = entity
});
driver.ClickWhenAvailable(By.XPath(Elements.Xpath[Reference.Process.BlankWorkflow]));
driver.ClickWhenAvailable(By.XPath(Elements.Xpath[Reference.Process.Create]));
return true;
}));
}
private void ReadTransitions(ProcessType processType)
{
if (processType.Transitions?.Transition == null)
{
return;
}
foreach (var transition in processType.Transitions.Transition)
{
var from = transition.From;
var to = transition.To;
PoolElement poolElement = null;
var guid = Guid.Parse(processType.Id);
if (_poolByProcessDictionary.TryGetValue(guid, out poolElement))
{
try
{
IBaseElement fromElement = _elements[Guid.Parse(from)];
IBaseElement toElement = _elements[Guid.Parse(to)];
ConnectionElement connection = new ConnectionElement(fromElement, toElement);
connection.Guid = Guid.Parse(transition.Id);
List <Point> points = GetPoints(transition.ConnectorGraphicsInfos);
connection.Points = points;
poolElement.Connections.Add(connection);
}
catch (KeyNotFoundException ex)
{
throw new BaseElementNotFoundException(ex);
}
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="FormProcess"/> class.
/// </summary>
/// <param name="processType">Type of the process.</param>
public FormProcess(ProcessType processType)
{
_processType = processType;
InitializeComponent();
switch (processType)
{
case ProcessType.FileWriter:
progressMeter.Style = ProgressBarStyle.Marquee;
_progressText = labelStatus.Text = string.Format("{0}...", APIResources.GOREDIT_TEXT_SAVING);
break;
case ProcessType.FileMove:
case ProcessType.FileCopy:
case ProcessType.FileExporter:
case ProcessType.FileImporter:
progressMeter.Style = ProgressBarStyle.Continuous;
_progressText = labelStatus.Text = string.Empty;
break;
case ProcessType.FileInfo:
progressMeter.Style = ProgressBarStyle.Marquee;
_progressText = labelStatus.Text = APIResources.GOREDIT_TEXT_GET_FILE_INFO;
break;
}
}
public static string GetProcessTypeToString(ProcessType processType)
{
string text = "系统运转状态：";
switch (processType)
{
case ProcessType.init:
text += "正在初始化...";
break;
case ProcessType.Sensor:
text += "正在采集传感器数据...";
break;
case ProcessType.CodCollection:
text += "正在采集Cod数据...";
break;
case ProcessType.SampleWater:
text += "正在取水样...";
break;
case ProcessType.StandDil:
text += "正在稀释标定液...";
break;
case ProcessType.SampleDil:
text += "正在稀释样液...";
break;
case ProcessType.BodStand:
text += "正在标定BOD...";
break;
case ProcessType.BodSample:
text += "正在测量BOD...";
break;
case ProcessType.BodSampleComplete:
text += "测量BOD完成....";
break;
case ProcessType.BodWash:
text += "正在清洗BOD...";
break;
case ProcessType.DrainEmpty:
text += "正在排空溶液...";
break;
case ProcessType.Waitding:
text += "系统空闲...";
break;
default:
break;
}
return(text);
}
/// <summary>
/// Finds and creates all processes of a process type in the current situation. The function
/// will generate the found processes and add the relevant elements in the situation description.
/// </summary>
/// <param name="processType">
/// The process type of which new processes will be searched in the situation
/// </param>
/// <param name="mappingRules">
/// A collection of all objects mapping rules from the domain theory
/// </param>
/// <returns>A collection of the found NEW processes of this type</returns>
public ICollection <Process> CreateProcesses(ProcessType processType, ICollection <ObjectMappingRule> mappingRules)
{
List <Process> newProcesses = new List <Process>();
List <ObjectRelation> situationObjectRelations = ObjectRelations.Distinct().ToList();
List <ObjectInstance> situationObjects = Objects.Distinct().ToList();
// Each item in the collection can be used as a base for a new process.
ICollection <ProcessRolesMap> possibleProcessRoleMaps = processType.Precondition.GetPossibleRoleMaps(situationObjects, situationObjectRelations);
foreach (ProcessRolesMap rolesMap in possibleProcessRoleMaps)
{
var newProcess = new Process(processType, rolesMap);
// Add the process in the situation if not already existing
if (this.Processes.All(pr => !pr.IsSameAs(newProcess)))
{
this.Processes.Add(newProcess);
// Creating the process effect elements and adding them in the process and the
// situation descriptions
CreateEffectElements(newProcess, mappingRules);
newProcesses.Add(newProcess);
}
}
return(newProcesses);
}
public async Task <string> GetProcessNumber(ProcessType processType, int id)
{
string prefix = string.Empty;
string process = processType.ToString();
for (int i = 0; i < process.Length; i++)
{
if (char.IsUpper(process[i]))
{
prefix += process[i];
}
}
StringBuilder consecutiveNumberBuilder = new StringBuilder(id.ToString());
for (int i = 0; i < 5 - consecutiveNumberBuilder.Length; i++)
{
consecutiveNumberBuilder.Insert(0, "0");
}
string prefixPart = _random.Next(100, 999).ToString();
string bodyPart = _random.Next(100, 999).ToString();
return($"{prefix}{prefixPart}-{bodyPart}-{consecutiveNumberBuilder}");
}
public void Save()
{
var type = new ProcessType(TYPENAME
, new ProcessType.WorkflowDefinition("")
, Taobao.Workflow.Activities.Test.Stub.WorkflowParser.GetActivitySettings().ToArray()) { Group = "test" };
this._processTypeService.Create(type);
Assert.AreNotEqual(Guid.Empty, type.ID);
}
public Section(byte[] id, ProcessType type, string name, string name2, int imageIndex)
{
this.id = id;
this.type = type;
this.name = name;
this.name2 = name2;
this.imageIndex = imageIndex;
}
public IProcess CreateNextProcess(ProcessType prevProcessType) {
IProcess nextProcess = null;
switch (prevProcessType) {
case ProcessType.Default: nextProcess = new PerformanceProcess(); break;
case ProcessType.End: break;
}
return nextProcess;
}
public IXPathNavigable GetAllProcessRuns(int processId, ProcessType processType) {
DataTable subComponents = this.m_model.GetChildComponents(processId);
XmlDocument doc = new XmlDocument();
XmlDeclaration declaration = doc.CreateXmlDeclaration("1.0", "UTF-8", String.Empty);
doc.AppendChild(declaration);
String rootName = String.Empty;
String runName = String.Empty;
switch (processType) {
case ProcessType.OPTIMIZATION:
rootName = "Optimization";
runName = "OptRun";
break;
case ProcessType.SIMULATION:
rootName = "Simulation";
runName = "SimRun";
break;
default:
throw new Exception("The Process Type is not defined in the ProcessControllType enum");
}
XmlElement root = doc.CreateElement(rootName);
root.SetAttribute("id", processId.ToString());
doc.AppendChild(root);
int id;
String name;
DataTable parameters;
XmlElement runNode;
foreach (DataRow simRunRows in subComponents.Rows) {
id = (int)simRunRows[SchemaConstants.Id];
runNode = doc.CreateElement(runName);
runNode.SetAttribute("id", id.ToString());
name = simRunRows[SchemaConstants.Name].ToString();
runNode.SetAttribute("name", name);
root.AppendChild(runNode);
parameters = this.m_model.GetParameterTable(id, eParamParentType.Component.ToString());
XmlElement parameterNode;
String parameterId, parameterName, parameterValue;
foreach (DataRow parameterRows in parameters.Rows) {
parameterId = parameterRows[SchemaConstants.Id].ToString();
parameterName = parameterRows[SchemaConstants.Name].ToString();
parameterValue = parameterRows[SchemaConstants.Value].ToString();
parameterNode = doc.CreateElement("Parameter");
parameterNode.SetAttribute("name", parameterName);
parameterNode.SetAttribute("value", parameterValue);
runNode.AppendChild(parameterNode);
}
}
return doc.Clone();
}
private static void GenerateReport(ProcessRepository process, ProcessType type)
{
tracer.Info("Generating report for {0}...", type);
var flow = process.GetFlow(type);
var generator = new FlowIssueGenerator(type, flow);
var body = generator.Render();
var baseDir = GitRepo.Find(".") ?? ".";
var output = Path.Combine(baseDir, "~" + type + ".md");
File.WriteAllText(output, body, Encoding.UTF8);
}
public Process( string name, string url, Site site, ProcessType type )
{
this.name = name;
this.url = url;
this.site = site;
this.type = type;
Regex pattern = new Regex( @"tcp://(?<ip>.*):(?<port>\d+)/(?<servicename>\w+)" );
Match match = pattern.Match( url );
if ( match.Success ) {
ip = match.Groups[ "ip" ].Value;
port = match.Groups[ "port" ].Value;
serviceName = match.Groups[ "servicename" ].Value;
}
}
/// <summary>
/// 实例化一道工序为指定参数
/// </summary>
/// <param name="stationNo">工位号</param>
/// <param name="processType">加工类型</param>
/// <param name="processShape">加工形状</param>
/// <param name="number">工序号</param>
/// <param name="startPoint">工序的起始点</param>
public Process(ProcessType processType, ProcessShape processShape, bool isOutside, int number, Point startPoint)
: this()
{
//保存加工类型
this.ProcessType = processType;
//保存加工形状
this.ProcessShape = processShape;
//保存工序号
this.Number = number;
//保存起始点
setStartPoint(startPoint);
this.IsOutside = isOutside;
//获取加工面类型
getSideType();
}
public AssessmentToolStrip(ProcessType type) : this() {
AMEManager cm = AMEManager.Instance;
Controller projectController = (Controller)cm.Get("ProjectEditor");
String typeString = null;
switch (type) {
case (ProcessType.SIMULATION):
this.config = "AssessmentEditor";
this.measureConfig = "SimMeasuresEditor";
this.assessmentController = (AssessmentController)cm.Get(this.config);
typeString = " for Simulation";
this.processButton.ToolTipText = "Simulation";
this.Items.AddRange(new System.Windows.Forms.ToolStripItem[] {
this.processComboBox,
this.toolStripSeparator,
this.graphButton,
this.processButton});
break;
case (ProcessType.OPTIMIZATION):
this.config = "OptAssessmentEditor";
this.measureConfig = "OptMeasuresEditor";
this.assessmentController = (AssessmentController)cm.Get(this.config);
typeString = " for Optimization";
this.processButton.ToolTipText = "Optimization";
this.Items.AddRange(new System.Windows.Forms.ToolStripItem[] {
this.processComboBox,
this.toolStripSeparator,
this.graphButton,
this.applyResultsButton,
this.processButton});
break;
default:
throw new Exception("Attempt to create an unkown type of the AssessmentToolstrip");
}
this.assessmentController.RegisterForUpdate(processComboBox);
// Init Simulation Selection CustomCombo
this.processComboBox.Controller = projectController;
this.processComboBox.Type = assessmentController.RootComponentType;
this.processComboBox.LinkType = projectController.RootComponentType;
logger.Debug("Created AssessmentToolStrip" + typeString);
}
public void Handle( ProcessType type )
{
switch( type )
{
case ProcessType.Welcome:
welcome.Go();
break;
case ProcessType.Shop:
shop.Go();
break;
case ProcessType.Purchase:
purchase.Go();
break;
case ProcessType.Exit:
exit.Go();
break;
}
}
public ProcessPanel(ProcessType type) : this() {
//projectController = (RootController)GMEManager.Instance.Get("ProjectEditor");
String typeStr = String.Empty;
switch (type) {
case ProcessType.OPTIMIZATION:
modelingController = (ModelingController)AMEManager.Instance.Get("OptimizationEditor");
measuresController = (MeasuresController)AMEManager.Instance.Get("OptMeasuresEditor");
typeStr = "Optimization";
break;
case ProcessType.SIMULATION:
modelingController = (ModelingController)AMEManager.Instance.Get("SimulationEditor");
measuresController = (MeasuresController)AMEManager.Instance.Get("SimMeasuresEditor");
typeStr = "Simulation";
break;
default:
throw new Exception("The Process Type is not defined in the ProcessControllType enum");
}
if (modelingController == null)
return;
this.topTabPage.Description = "Select " + typeStr + " to run";
this.topTabPage.Text = typeStr;
this.bottomTabPage.Description = "Configure and Run the " + typeStr + "Run";
this.bottomTabPage.Text = typeStr + "Run";
processCustomCombo.Controller = projectController;
processCustomCombo.Type = modelingController.RootComponentType;
processCustomCombo.LinkType = projectController.RootComponentType;
parameterTable.Controller = modelingController;
modelingController.RegisterForUpdate(this);
modelingController.RegisterForUpdate(processCustomCombo);
modelingController.RegisterForUpdate(parameterTable);
customComboList = new List<CustomCombo>();
}
public void Send(string title, string content, ProcessType type = ProcessType.Normal)
{
if (type == ProcessType.Normal)
{
instanceMail.Send(title, content);
}
else
{
try
{
MailSendAdminHandler sendAdmin = new MailSendAdminHandler(instanceMail.Send);
sendAdmin.BeginInvoke(title, content, null, null);
}
catch (Exception ex)
{
LogManager.SqlDB.Write("Asecron Mail Gönderim", ex);
}
}
}
public static void RepertoryImage(Graphics drawDestination, ProcessType type)
{
StringFormat itemStringFormat = new StringFormat();
RectangleF itemBox = new RectangleF(10, 10, 60, 20);
Pen pen = new Pen(Color.Black);
float[] pattern = {3f,3f};
if(MSCItem.Style == MscStyle.UML2){
pen.DashStyle = System.Drawing.Drawing2D.DashStyle.Custom;
pen.DashPattern = pattern;
}
else if (MSCItem.Style == MscStyle.SDL){
pen.DashStyle = System.Drawing.Drawing2D.DashStyle.Solid;
}
if(type == ProcessType.Actor){
itemBox = new RectangleF(10, 0, 60, 14);
itemStringFormat.Alignment = StringAlignment.Center;
itemStringFormat.LineAlignment = StringAlignment.Near;
drawDestination.DrawString("Description",new Font("Arial",8),Brushes.Black,itemBox,itemStringFormat);
itemStringFormat.LineAlignment = StringAlignment.Center;
drawDestination.DrawEllipse(Pens.Black,36,14,8,8);
drawDestination.DrawLine(Pens.Black,40,22,40,32);
drawDestination.DrawLine(Pens.Black,32,24,48,24);
drawDestination.DrawLine(Pens.Black,40,32,48,40);
drawDestination.DrawLine(Pens.Black,40,32,32,40);
itemBox = new RectangleF(10, 42, 60, 12);
drawDestination.DrawString("Actor",new Font("Arial",8),Brushes.Black,itemBox,itemStringFormat);
drawDestination.DrawLine(pen,40,56,40,75);
}
else if (type == ProcessType.Normal){
itemBox = new RectangleF(10, 0, 60, 14);
itemStringFormat.Alignment = StringAlignment.Center;
itemStringFormat.LineAlignment = StringAlignment.Near;
drawDestination.DrawString("Description",new Font("Arial",8),Brushes.Black,itemBox,itemStringFormat);
itemStringFormat.LineAlignment = StringAlignment.Center;
drawDestination.FillRectangle(Brushes.White,10,14,60,20);
itemBox = new RectangleF(10, 14, 60, 20);
drawDestination.DrawString("Process",new Font("Arial",8),Brushes.Black,itemBox,itemStringFormat);
drawDestination.DrawRectangle(Pens.Black,10,14,60,20);
drawDestination.DrawLine(pen,40,34,40,75);
}
itemStringFormat.Dispose();
pen.Dispose();
}
public Form2(PassingType pt, ProcessType proc)
{
InitializeComponent();
label1.Visible = false;
panel1.AutoScroll = true;
previewPicture.Location = new Point(0, 0);
previewPicture.SizeMode = PictureBoxSizeMode.Zoom;
PassingType pts = PassingType.Denoise4;
switch (pt)
{
case PassingType.Binary:
this.Text = "二值图";
pts = PassingType.Binary;
break;
case PassingType.Noise:
this.Text = "噪声图";
pts = PassingType.Noise;
break;
case PassingType.Denoise4:
this.Text = "四邻域探测去噪图";
pts = PassingType.Denoise4;
break;
case PassingType.Denoise8:
this.Text = "八邻域探测去噪图";
pts = PassingType.Denoise8;
break;
default:
this.Text = "浏览";
break;
}
if (pt >= PassingType.Denoise4)
{
this.Text += " （" + (proc == ProcessType.Climbing ? "爬山算法" : "模拟退火算法") + "） ";
}
core.passOut(pts, ref preImage);
previewPicture.Image = preImage;
if (pt >= PassingType.Denoise4)
{
label1.Text = "去噪率：" + (core.getRate() * 100).ToString("0.000") + "%";
label1.Visible = true;
}
}
public List<StrategyOrderInfo> ProcessSymbol(string StrategyId, string[] symbol, ProcessType _processType)
{
if (symbol == null || symbol.Count() == 0)
{
for (int i = 0; i < MockupManager.StrategyOrderList.Count; i++)
{
StrategyOrderInfo order = MockupManager.StrategyOrderList[i];
ProcessOrder(_processType, order);
}
}
else if (symbol != null && symbol.Count() > 0)
{
for (int i = 0; i < MockupManager.StrategyOrderList.Count; i++)
{
StrategyOrderInfo order = MockupManager.StrategyOrderList[i];
if (symbol.Contains(order.Symbol))
{
ProcessOrder(_processType, order);
}
}
}
return MockupManager.StrategyOrderList;
}
static void ProcessPartition(Database db, string tableName, string partitionName, ProcessType type, string sql = null)
{
var id = db.Dimensions.GetByName(tableName).ID;
using (var measureGroup = db.Cubes[0].MeasureGroups[id])
{
using (var p = measureGroup.Partitions.GetByName(partitionName))
{
try
{
if (sql == null)
{
p.Process(type);
}
else
{
p.Process(type, new QueryBinding(db.DataSourceViews[0].ID, sql));
}
}
catch (OperationException oe)
{
//Partition is empty
//TODO: Find better way to check if this is the cause of the exception. HResult just says "Unspecified error".
if (type == ProcessType.ProcessAdd)
{
ProcessPartition(db, tableName, partitionName, ProcessType.ProcessFull, sql);
}
else
{
throw oe;
}
}
}
}
}
public List<ImportedFileStatus> ImportedFileStatusLoadByTypeStatusFileType(ProcessType processType, ProcessStatus processStatus, ProcessFileType processFileType)
{
List<ImportedFileStatus> result = new List<ImportedFileStatus>();
StoredProcedure proc = new StoredProcedure(SQLResource.ImportedFileStatusSelectByTypeStatusFileType, ConnectionString);
proc.Parameters.AddWithValue("@ProcessTypeID", processType);
proc.Parameters.AddWithValue("@ProcessStatusID", processStatus);
proc.Parameters.AddWithValue("@ProcessFileTypeID", processFileType);
DataTable table = proc.ExecuteReader();
foreach (DataRow row in table.Rows)
{
ImportedFileStatus file = new ImportedFileStatus(row);
result.Add(file);
}
return result;
}
internal List<StrategyOrderInfo> ProcessAllSymbol(string StrategyId, ProcessType processType)
{
List<StrategyOrderInfo> returnStrategyOrderList = new List<StrategyOrderInfo>();
for (int i = 0; i < StrategyOrderList.Count; i++)
{
if (StrategyOrderList[i].StrategyId == StrategyId)
{
StrategyOrderInfo order = StrategyOrderList[i];
if (processType == ProcessType.START)
{
order.Status = "Trading";
}
else if (processType == ProcessType.STOP)
{
order.Status = "Stopped";
}
else if (processType == ProcessType.CANCELALL)
{
order.Status = "Cancel";
}
else if (processType == ProcessType.LOCK)
{
order.Status = "Locked";
}
else if (processType == ProcessType.UNLOCK)
{
order.Status = "Stoped";
}
returnStrategyOrderList.Add(order);
}
}
return returnStrategyOrderList;
}
public void AddProcess(uint fileLine, string id, string name, string description, Brush brush, uint line, ProcessType type, uint leftRand, uint rightRand)
{
processes.Add(new Process(id, brush,leftRand, rightRand));
lines.Add(new ProcessLine(fileLine, name,description, line,processes.Count-1,type,null,leftRand, rightRand,null));
}
public override void OnInspectorGUI()
{
Tools.current = Tool.View;
EditorGUILayout.Space();
serializedObject.Update();
GUI.changed = false;
// 创建格子
folds[0] = EditorGUILayout.BeginToggleGroup("创建格子", folds[0]);
if (folds[0])
{
GUILayout.Label("注意这会删除当前格子", EditorStyles.label);
EditorGUILayout.Space();
EditorGUILayout.PropertyField(gridWidth, new GUIContent("格子宽(米)"));
EditorGUILayout.PropertyField(gridXNum, new GUIContent("X轴格子数"));
EditorGUILayout.PropertyField(gridZNum, new GUIContent("Z轴格子数"));
if (GUILayout.Button("Update"))
{
Target.Reset();
}
}
EditorGUILayout.EndToggleGroup();
// 刷格子
GUILayout.Space(20f);
folds[1] = EditorGUILayout.BeginToggleGroup("刷阻挡", folds[1]);
if (folds[1])
{
EditorGUILayout.Space();
Target.ShowGrids = EditorGUILayout.Toggle("显示格子", Target.ShowGrids);
this.curProcessType = (ProcessType)EditorGUILayout.EnumPopup("当前操作类型", this.curProcessType);
if (this.curProcessType == ProcessType.Set || this.curProcessType == ProcessType.Clear)
{
this.curTileType = (TileType)EditorGUILayout.EnumPopup("当前格子类型", this.curTileType);
this.radius = EditorGUILayout.IntSlider("操作直径", this.radius, 1, 16);
}
else if (this.curProcessType == ProcessType.FindPath)
{
vecStart = EditorGUILayout.Vector3Field("起始点", vecStart);
vecEnd = EditorGUILayout.Vector3Field("结束点", vecEnd);
}
}
EditorGUILayout.EndToggleGroup();
if (GUI.changed || Target.ShowGrids)
EditorUtility.SetDirty(this.target);
// 导出地图信息
GUILayout.Space(20f);
folds[2] = EditorGUILayout.BeginToggleGroup("导出地图信息", folds[2]);
if (folds[2])
{
EditorGUILayout.Space();
if (GUILayout.Button("Export"))
{
Export();
}
}
EditorGUILayout.EndToggleGroup();
serializedObject.ApplyModifiedProperties();
}
private Client.ProcessType Parse(ProcessType processType)
{
var activity = this._workflowParser.Parse(WorkflowBuilder.GetCacheKey(processType)
, processType.Workflow.Serialized
, processType.ActivitySettings);
return new Client.ProcessType()
{
CreateTime = processType.CreateTime,
Description = processType.Description,
Name = processType.Name,
Version = processType.Version,
IsCurrent = processType.IsCurrent,
Group = processType.Group,
ActivityNames = processType.ActivitySettings.Select(o => o.ActivityName).ToArray(),
DataFields = activity.Variables.Select(o => o.Name).ToArray()
};
}
public List<StrategyOrderInfo> ProcessSymbol(string StrategyId, string[] symbol, ProcessType _processType)
{
string logMessage = string.Format("Class: {0}, Method: {1}", "CommunicationManager", "ProcessSymbol(...)");
LogUtil.WriteLog(LogLevel.DEBUG, logMessage);
string symbolSpec = null;
if (symbol != null)
{
symbolSpec = EZXWPFLibrary.Utils.StringUtils.StringListToText(symbol.ToList(), ",");
}
List<StrategyOrderInfo> StrategyOrderList = new List<StrategyOrderInfo>();
strategyResultsUpdate update = new strategyResultsUpdate();
switch (_processType)
{
case ProcessType.START:
update = Service.start(symbolSpec);
break;
case ProcessType.STOP:
update = Service.stop(symbolSpec);
break;
case ProcessType.CANCELALL:
Service.cancelAll(symbolSpec);
update = Service.getUpdates();
break;
case ProcessType.LOCK:
update = Service.@lock(symbolSpec);
break;
case ProcessType.UNLOCK:
update = Service.unlock(symbolSpec);
break;
case ProcessType.UNWIND:
update = Service.getUpdates();
break;
case ProcessType.BUY:
update = Service.buy(symbolSpec);
break;
case ProcessType.SELL:
update = Service.sell(symbolSpec);
break;
case ProcessType.BOTH:
update = Service.both(symbolSpec);
break;
}
symbolUpdate[] StrategyOrderSRVList = update.updates;
CovertServiceObjectToClinetObject(StrategyOrderList, StrategyOrderSRVList, update.strategyName);
SetServerStatus(update);
return StrategyOrderList;
}
private void GetSelectedStrategyAndSymbol(Dictionary<string, List<string>> selectedStrategyAndSymbol, ProcessType _processType)
{
App.AppManager.DataMgr.ClearProcessSelectionIndication();
if (fltdg.SelectedItems != null)
{
for (int i = 0; i < fltdg.SelectedItems.Count; i++)
{
StrategyOrderInfo orderInfo = fltdg.SelectedItems[i] as StrategyOrderInfo;
if (orderInfo != null)
{
if (_processType == ProcessType.BUY
|| _processType == ProcessType.SELL
|| _processType == ProcessType.BOTH)
{
if (orderInfo.Status.Equals("Trading"))
{
if (_processType.ToString().ToLower().Equals(orderInfo.TradingMode.ToLower()))
{
orderInfo.IsAlreadyHadSameProcess = true;
//Avoid re-setting the symbol with same trading-mode as before
continue;
}
orderInfo.InProcess = true;
if (!selectedStrategyAndSymbol.ContainsKey(orderInfo.StrategyId))
{
selectedStrategyAndSymbol[orderInfo.StrategyId] = new List<string>();
}
selectedStrategyAndSymbol[orderInfo.StrategyId].Add(orderInfo.Symbol);
}
}
else if (_processType == ProcessType.UNLOCK)
{
if (orderInfo.Status.Equals("Locked"))
{
orderInfo.InProcess = true;
if (!selectedStrategyAndSymbol.ContainsKey(orderInfo.StrategyId))
{
selectedStrategyAndSymbol[orderInfo.StrategyId] = new List<string>();
}
selectedStrategyAndSymbol[orderInfo.StrategyId].Add(orderInfo.Symbol);
}
}
else if (_processType == ProcessType.START)
{
if (!orderInfo.Status.Equals("Trading") && !orderInfo.Status.Equals("Locked"))
{
orderInfo.InProcess = true;
if (!selectedStrategyAndSymbol.ContainsKey(orderInfo.StrategyId))
{
selectedStrategyAndSymbol[orderInfo.StrategyId] = new List<string>();
}
selectedStrategyAndSymbol[orderInfo.StrategyId].Add(orderInfo.Symbol);
}
}
else if (_processType == ProcessType.STOP)
{
if (!orderInfo.Status.Equals("Stopped") && !orderInfo.Status.Equals("Locked"))
{
orderInfo.InProcess = true;
if (!selectedStrategyAndSymbol.ContainsKey(orderInfo.StrategyId))
{
selectedStrategyAndSymbol[orderInfo.StrategyId] = new List<string>();
}
selectedStrategyAndSymbol[orderInfo.StrategyId].Add(orderInfo.Symbol);
}
}
else if (orderInfo.Status.Equals("Locked"))
{
orderInfo.InProcess = true;
if (!selectedStrategyAndSymbol.ContainsKey(orderInfo.StrategyId))
{
selectedStrategyAndSymbol[orderInfo.StrategyId] = new List<string>();
}
selectedStrategyAndSymbol[orderInfo.StrategyId].Add(orderInfo.Symbol);
}
else
{
orderInfo.InProcess = true;
if (!selectedStrategyAndSymbol.ContainsKey(orderInfo.StrategyId))
{
selectedStrategyAndSymbol[orderInfo.StrategyId] = new List<string>();
}
selectedStrategyAndSymbol[orderInfo.StrategyId].Add(orderInfo.Symbol);
}
}
}
}
}
private string GetTradingModeValue(ProcessType _processType)
{
if (_processType == ProcessType.BUY)
{
return "Buy";
}
else if (_processType == ProcessType.SELL)
{
return "Sell";
}
else if (_processType == ProcessType.BOTH)
{
return "Both";
}
return "";
}
public ProcessClass(string ProcessInfo)
{
_StartInfo = new ProcessStartInfo(@ProcessInfo);
_TypeApplication = ProcessType.Application;
}
public Section(byte[] id, ProcessType type, string name, int imageIndex)
: this(id, type, name, "", imageIndex)
{
}
/**
* Example: [process] [arguments]
* pict.exe input.txt > output.txt
* */
public void AddArguments(string args)
{
_StartInfo.Arguments = args;
_TypeApplication = ProcessType.ApplicationWithArguments;
}
private ProcessType CreateProcessType(string name
, string workflowDefinition
, string activitySettingsDefinition
, string description
, string group
, bool current)
{
var type = new ProcessType(name
, new ProcessType.WorkflowDefinition(workflowDefinition)
, this._workflowParser.ParseActivitySettings(workflowDefinition, activitySettingsDefinition))
{
Description = description,
Group = group
};
this._processTypeService.Create(type, current);
return type;
}
public List<StrategyOrderInfo> ProcessAllSymbol(string StrategyId, ProcessType _processType)
{
string logMessage = string.Format("Class: {0}, Method: {1}", "CommunicationManager", "ProcessAllSymbol(...)");
LogUtil.WriteLog(LogLevel.DEBUG, logMessage);
return ProcessSymbol(StrategyId, null, _processType);
}