public ConsoleForm(Instance inst)
{
this.inst = inst;
Text = inst.Name + " is running...";
InitializeComponent();
if (inst.InstProcess != null)
{
Message("Instance started with command: " + inst.InstProcess.StartInfo.FileName +
" " + inst.InstProcess.StartInfo.Arguments.ToString());
inst.InstQuit += new EventHandler<InstQuitEventArgs>(InstQuit);
inst.InstProcess.OutputDataReceived += new DataReceivedEventHandler(InstOutput);
inst.InstProcess.ErrorDataReceived += new DataReceivedEventHandler(InstOutput);
inst.InstProcess.BeginOutputReadLine();
inst.InstProcess.BeginErrorReadLine();
}
trayIcon.Visible = true;
trayIcon.DoubleClick += (o, args) => ShowConsole = !ShowConsole;
showConsoleToolStripMenuItem.Checked = ShowConsole;
}
private void Register()
{
try
{
if (!config.InstanceKey.HasValue || reregister)
{
try
{
var instances = new Instances(config);
Instance instance = new Instance() { TargetKey = config.TargetKey };
instances.CreateInstance(instance);
config.InstanceKey = instance.Key;
}
catch (Exception ex)
{
throw new DeploymentException("Failed registering instance.", ex);
}
try
{
Utils.Registry.Save(config);
}
catch (Exception ex)
{
throw new DeploymentException("Failed updating config after instance registration.", ex);
}
}
}
catch (Exception ex)
{
this.EventLog.WriteEntry("Failed service registration: " + ex.ToString(), EventLogEntryType.Error);
throw;
}
reregister = false;
}
public static void Run () {
var model = new StateMachine<Instance>("history");
var initial = new PseudoState<Instance>("initial", model, PseudoStateKind.Initial);
var shallow = new State<Instance>("shallow", model);
var deep = new State<Instance>("deep", model);
var end = new FinalState<Instance>("final", model);
var s1 = new State<Instance>("s1", shallow);
var s2 = new State<Instance>("s2", shallow);
initial.To(shallow);
new PseudoState<Instance>("shallow", shallow, PseudoStateKind.ShallowHistory).To(s1);
s1.To(s2).When<string>(c => c == "move");
shallow.To(deep).When<string>(c => c == "go deep");
deep.To(shallow).When<string>(c => c == "go shallow");
s2.To(end).When<string>(c => c == "end");
model.Validate();
var instance = new Instance("history");
model.Initialise(instance);
model.Evaluate(instance, "move");
model.Evaluate(instance, "go deep");
model.Evaluate(instance, "go shallow");
model.Evaluate(instance, "end");
Trace.Assert(model.IsComplete(instance));
}
/// <summary> Gets class probability for instance.
///
/// </summary>
/// <exception cref="Exception">if something goes wrong
/// </exception>
public virtual double classProb(int classIndex, Instance instance, int theSubset)
{
if (theSubset > - 1)
{
return m_distribution.prob(classIndex, theSubset);
}
else
{
double[] weights = GetWeights(instance);
if (weights == null)
{
return m_distribution.prob(classIndex);
}
else
{
double prob = 0;
for (int i = 0; i < weights.Length; i++)
{
prob += weights[i] * m_distribution.prob(classIndex, i);
}
return prob;
}
}
}
public IInstance Create(Configuration.ISettings configurationSettings)
{
Instance instance = new Instance(configurationSettings, _connectionFactory, _messageSerializer);
instance.Connect();
return instance;
}
public static unsafe bool Compute( Instance instance, double* points, int pointCount, int* triangles,
int triangleCount, int maxTrianglesInDecimatedMesh, int maxVerticesPerConvexHull )
{
bool result = HACD_Compute( instance.nativeObject, points, pointCount, triangles, triangleCount,
maxTrianglesInDecimatedMesh, maxVerticesPerConvexHull );
return result;
}
public static void Run () {
var model = new StateMachine<Instance>("model");
var initial = new PseudoState<Instance>("initial", model, PseudoStateKind.Initial);
var target = new State<Instance>("state", model).Entry(i => i.Int1++).Exit(i => i.Int2++);
initial.To(target);
target.To().When<string>(m => m == "internal").Effect(i => i.Int3++);
target.To(target).When<string>(m => m == "external").Effect(i => i.Int3++);
var instance = new Instance("internal");
model.Validate();
model.Initialise(instance);
model.Evaluate(instance, "internal");
Trace.Assert(target == instance.GetCurrent(model.DefaultRegion));
Trace.Assert(1 == instance.Int1);
Trace.Assert(0 == instance.Int2);
Trace.Assert(1 == instance.Int3);
model.Evaluate(instance, "external");
Trace.Assert(target == instance.GetCurrent(model.DefaultRegion));
Trace.Assert(2 == instance.Int1);
Trace.Assert(1 == instance.Int2);
Trace.Assert(2 == instance.Int3);
}
/// <summary>
/// Create and remember a reference to an Instance.
/// </summary>
/// <param name="instance"></param>
/// <param name="station">station to which this instance belongs</param>
/// <returns>new instance reference</returns>
public InstanceRef AddRef(Instance instance, Station station)
{
long id = NextId();
InstanceRef iRef = new InstanceRefImpl(id, instance, station);
refs.Add(id, iRef);
return iRef;
}
public static void Run () {
var model = new StateMachine<Instance>("model");
var initial = new PseudoState<Instance>("initial", model, PseudoStateKind.Initial);
var junction1 = new PseudoState<Instance>("junction1", model, PseudoStateKind.Junction);
var junction2 = new PseudoState<Instance>("junction2", model, PseudoStateKind.Junction);
var pass = new State<Instance>("success", model);
var fail = new State<Instance>("error", model);
initial.To(junction1);
junction1.To(junction2).When(i => i.Int1 == 0).Effect(i => i.Int1++);
junction1.To(fail).Else();
junction2.To(pass).When(i => i.Int1 == 0).Effect(i => i.Int1++);
junction2.To(fail).Else();
model.Validate();
var instance = new Instance("static");
model.Initialise(instance);
Trace.Assert(pass == instance.GetCurrent(model.DefaultRegion));
Trace.Assert(2 == instance.Int1);
}
/// <summary>
/// Loads the list of Windows credentials associated with <paramref name="instance"/>.
/// </summary>
/// <param name="instance">The GCE VM</param>
/// <returns>The list of <seealso cref="WindowsInstanceCredentials"/> associated with The GCE VM. It might be
/// empty if no credentials are found.</returns>
public IEnumerable<WindowsInstanceCredentials> GetCredentialsForInstance(Instance instance)
{
var instancePath = GetInstancePath(instance);
IEnumerable<WindowsInstanceCredentials> result;
if (_credentialsForInstance.TryGetValue(instancePath, out result))
{
return result;
}
var instanceStoragePath = GetStoragePathForInstance(instance);
if (!Directory.Exists(instanceStoragePath))
{
result = Enumerable.Empty<WindowsInstanceCredentials>();
}
else
{
result = Directory.EnumerateFiles(instanceStoragePath)
.Where(x => Path.GetExtension(x) == PasswordFileExtension)
.Select(x => LoadEncryptedCredentials(x))
.OrderBy(x => x.User);
}
_credentialsForInstance[instancePath] = result;
return result;
}
public int SaveInstance(IInstanceDb instanceDb, int? transactionNumber = null)
{
if (instanceDb.InstanceId != _instanceId)
throw new Exception("Attempt to save Instance with wrong InstanceId");
Instance record;
var recordOld = new Instance();
if (instanceDb.InstanceId == 0)
{
record = new Instance();
Context.AddToInstances(record);
}
else
{
record = Context.Instances.Where(r => r.InstanceId == instanceDb.InstanceId).First();
ReflectionHelper.CopyAllProperties(record, recordOld);
}
record.InstanceName = instanceDb.InstanceName;
Context.SaveChanges();
if (instanceDb.InstanceId == 0)
{
instanceDb.InstanceId = record.InstanceId;
LogToDb(UserId, "Instances", record.InstanceId, "I", XmlHelper.GetObjectXml(record), transactionNumber);
}
else
{
LogToDb(UserId, "Instances", record.InstanceId, "U", XmlHelper.GetDifferenceXml(recordOld, record), transactionNumber);
}
return instanceDb.InstanceId;
}
public static void Run () {
var model = new StateMachine<Instance>("compTest");
var initial = new PseudoState<Instance>("initial", model, PseudoStateKind.Initial);
var activity1 = new State<Instance>("activity1", model);
var activity2 = new State<Instance>("activity2", model);
var activity3 = new State<Instance>("activity3", model);
var junction1 = new PseudoState<Instance>("junction1", model, PseudoStateKind.Junction);
var junction2 = new PseudoState<Instance>("junction2", model, PseudoStateKind.Junction);
var end = new FinalState<Instance>("end", model);
var subInitial = new PseudoState<Instance>("subInitial", activity2, PseudoStateKind.Initial);
var subEnd = new FinalState<Instance>("subEnd", activity2);
subInitial.To(subEnd);
initial.To(activity1);
activity1.To(activity2);
activity2.To(junction1);
junction1.To(junction2).Else();
junction2.To(activity3).Else();
activity3.To(end);
model.Validate();
var instance = new Instance("transitions");
model.Initialise(instance);
Trace.Assert(model.IsComplete(instance));
}
public void ActivateHoverTooltip(Instance currentInstnace)
{
this.instance = currentInstnace;
ConstructTooltipDataString();
hoverTooltip.SetActive(true);
}
public EncoreClient()
{
encoreClient = new Utilities();
encoreInstance = new Instance();
encoreLogDetail = new LogDetail();
encoreLang = new Language();
}
public DBAppliedMigration[] GetAppliedMigrations(Instance instance)
{
List<DBAppliedMigration> result = new List<DBAppliedMigration>();
using (SqlConnection connection = new SqlConnection(connectionStringProvider.GetConnectionString(instance)))
{
connection.Open();
using (SqlCommand cmd = new SqlCommand(@"SELECT [Id]
,[Executed_at]
,[Executed_by]
,[MigrateScript]
,[RollbackScript]
,[Migration_id]
FROM [DBAppliedMigrations]
ORDER BY [Executed_at] DESC", connection))
{
using (SqlDataReader reader = cmd.ExecuteReader())
{
while (reader.Read())
{
DBAppliedMigration appliedMig = new DBAppliedMigration();
appliedMig.Id = reader.GetInt32(0);
appliedMig.At = reader.GetDateTime(1);
appliedMig.By = reader.GetString(2);
appliedMig.MigrateScript = reader.GetString(3);
appliedMig.RollbackScript = reader.GetString(4);
appliedMig.MigrationId = reader.GetInt32(5);
result.Add(appliedMig);
}
}
}
}
return result.ToArray();
}
public GceInstanceViewModel(GceSourceRootViewModel owner, Instance instance)
{
_owner = owner;
Instance = instance;
UpdateInstanceState();
}
public void InstanceSerialiseDeserialise()
{
var originalInstance = new Instance()
{
Key = Guid.NewGuid(),
GroupKey = Guid.NewGuid(),
TargetKey = Guid.NewGuid(),
Name = "Test Instance",
Tags = new Dictionary<string, string>()
{
{ "tagKey", "Some tag value." },
{ "secondKey", "Multiline \r\n test!" }
}
};
Instance secondInstance;
using (var stream = originalInstance.Serialise())
{
secondInstance = new Instance(stream);
}
Assert.AreEqual(originalInstance.Key, secondInstance.Key);
Assert.AreEqual(originalInstance.GroupKey, secondInstance.GroupKey);
Assert.AreEqual(originalInstance.TargetKey, secondInstance.TargetKey);
Assert.AreEqual(originalInstance.Name, secondInstance.Name);
Assert.IsNotNull(secondInstance.Tags);
foreach (var tag in originalInstance.Tags)
{
Assert.IsTrue(secondInstance.Tags.ContainsKey(tag.Key));
Assert.AreEqual(tag.Value, secondInstance.Tags[tag.Key]);
}
}
/// <summary> Constructor that generates a sparse instance from the given
/// instance. Reference to the dataset is set to null.
/// (ie. the instance doesn't have access to information about the
/// attribute types)
///
/// </summary>
/// <param name="instance">the instance from which the attribute values
/// and the weight are to be copied
/// </param>
public SparseInstance(Instance instance)
{
m_Weight = instance.m_Weight;
m_Dataset = null;
m_NumAttributes = instance.numAttributes();
if (instance is SparseInstance)
{
m_AttValues = ((SparseInstance) instance).m_AttValues;
m_Indices = ((SparseInstance) instance).m_Indices;
}
else
{
double[] tempValues = new double[instance.numAttributes()];
int[] tempIndices = new int[instance.numAttributes()];
int vals = 0;
for (int i = 0; i < instance.numAttributes(); i++)
{
if (instance.value_Renamed(i) != 0)
{
tempValues[vals] = instance.value_Renamed(i);
tempIndices[vals] = i;
vals++;
}
}
m_AttValues = new double[vals];
m_Indices = new int[vals];
Array.Copy(tempValues, 0, m_AttValues, 0, vals);
Array.Copy(tempIndices, 0, m_Indices, 0, vals);
}
}
public static void TestInstance(Assert assert)
{
assert.Expect(17);
var i = new Instance();
assert.Ok(i != null, "i created");
assert.Equal(i.Foo(1), "Foo(int x)", "Instance Foo(int x)");
assert.Equal(i.Foo("string"), "Foo(string s)", "Instance Foo(string s)");
assert.Equal(i.Foo(1.1), "Foo(double d)", "Instance Foo(double d)");
assert.Equal(i.Foo(1, 2), "Foo(int x, int y)", "Instance Foo(int x, int y)");
assert.Equal(i.Foo(1, 1.1), "Foo(int x, double y)", "Instance Foo(int x, double y)");
assert.Equal(i.Foo(1.1, 1), "Foo(double x, int y)", "Instance Foo(double x, int y)");
assert.Equal(i.FooReturnType(1), 'C', "Instance char FooReturnType(int y)");
assert.Equal(i.FooReturnType(1.1), "string FooReturnType(double d)", "Instance string FooReturnType(double d)");
assert.Equal(i.FooOptionalParameters(1), "FooOptionalParameters(int x)", "Instance FooOptionalParameters(int x)");
assert.Equal(i.FooOptionalParameters(1, 2), "FooOptionalParameters(int x, int y = 5)", "Instance FooOptionalParameters(int x, int y = 5)");
assert.Equal(i.FooMultipleOptionalParameters(1, 2), "FooMultipleOptionalParameters(int x, int y = 5)", "Instance FooMultipleOptionalParameters(int x, int y = 5)");
assert.Equal(i.FooMultipleOptionalParameters(1, z: 2), "FooMultipleOptionalParameters(int x, int y = 5, int z = 10)", "Instance FooMultipleOptionalParameters(int x, int y = 5, int z = 10)");
assert.Equal(i.FooMultipleOptionalParameters(1, 2, 3), "FooMultipleOptionalParameters(int x, int y = 5, int z = 10)", "Instance FooMultipleOptionalParameters(int x, int y = 5, int z = 10)");
assert.Equal(i.FooMultipleOptionalParameters(1, z: 2, y: 3), "FooMultipleOptionalParameters(int x, int y = 5, int z = 10)", "Instance FooMultipleOptionalParameters(int x, int y = 5, int z = 10)");
assert.Equal(i.FooNamedArgument(x: 1), "FooNamedArgument(int x)", "Static FooNamedArgument(int x)");
assert.Equal(i.FooNamedArgument(d: 1), "FooNamedArgument(double d)", "Static FooNamedArgument(double d)");
}
public static void Run () {
var model = new StateMachine<Instance>("model");
var initial = new PseudoState<Instance>("initial", model);
var choice = new PseudoState<Instance>("choice", model, PseudoStateKind.Choice);
var junction = new PseudoState<Instance>("junction", model, PseudoStateKind.Junction);
var finalState = new FinalState<Instance>("final", model);
initial.To(choice);
choice.To(junction).When(i => i.Int1 == 0).Effect(i => i.Int1 = 1);
choice.To(finalState).Else();
junction.To(choice).When(i => i.Int2 == 0).Effect(i => i.Int2 = 2);
model.Validate();
var instance = new Instance("else");
model.Initialise(instance);
Trace.Assert(model.IsComplete(instance));
Trace.Assert(instance.Int1 == 1);
Trace.Assert(instance.Int2 == 2);
}
public static void Shutdown( Instance instance )
{
if( instance.nativeObject != IntPtr.Zero )
{
HACD_Shutdown( instance.nativeObject );
instance.nativeObject = IntPtr.Zero;
}
}
public Game() {
manager = new Manager();
watcher = new Watcher(manager);
instance = new Instance();
save = new Save();
env = new Environments();
env.GUID = Guid.NewGuid();
}
private static string CreateRdpFile(Instance instance, WindowsInstanceCredentials credentials)
{
var instanceRootPath = WindowsCredentialsStore.Default.GetStoragePathForInstance(instance);
var rdpPath = Path.Combine(instanceRootPath, GetRdpFileName(credentials));
WriteRdpFile(rdpPath, instance, credentials);
return rdpPath;
}
/// <summary> Input an instance for filtering. Ordinarily the instance is processed
/// and made available for output immediately. Some filters require all
/// instances be read before producing output.
///
/// </summary>
/// <param name="instance">the input instance
/// </param>
/// <returns> true if the filtered instance may now be
/// collected with output().
/// </returns>
/// <exception cref="IllegalStateException">if no input format has been set.
/// </exception>
public override bool input(Instance instance)
{
if (getInputFormat() == null)
{
throw new System.SystemException("No input instance format defined");
}
return false;
}
private PortManagerWindow(Instance instance) : base(GoogleCloudExtension.Resources.PortManagerWindowCaption)
{
var viewModel = new PortManagerViewModel(this, instance);
Content = new PortManagerWindowContent
{
DataContext = viewModel,
};
}
public InstanceTreeViewItemViewModel(Instance instance, ApplicationTreeViewItemViewModel parentApplication)
: base(parentApplication, true)
{
Messenger.Default.Send<NotificationMessageAction<ICloudFoundryProvider>>(new NotificationMessageAction<ICloudFoundryProvider>(Messages.GetCloudFoundryProvider, p => this.provider = p));
this.app = parentApplication.Application;
this.instance = instance;
this.dispatcher = Dispatcher.CurrentDispatcher;
}
public IInstance CreateEndpoint(Settings.IValues settings)
{
Instance endpoint = new Instance(_socketFactory, _responseParser, settings.LocalCommandEndpoint, settings.OwlCommandEndpoint, settings.OwlCommandResponseTimeout, settings.OwlCommandKey);
Instrumentation.Command.Endpoint.CreatedAt(settings.LocalCommandEndpoint.Address.ToString(), settings.LocalCommandEndpoint.Port);
return endpoint;
}
public MainWindow(Instance instance, MinecraftSession session)
: base(Gtk.WindowType.Toplevel)
{
Instance = instance;
Session = session;
Build ();
titleLabel.Text = instance.Description.Name;
if (session != null)
usernameLabel.Markup = string.Format ("Logged in as <b>{0}</b>", Session.Username);
else {
var saved = GetSavedCredentials();
if (saved == null) {
usernameLabel.Markup = string.Format ("Click Play to Login");
} else {
usernameLabel.Markup = string.Format ("Welcome back <b>{0}</b>!", saved.AutoLoginUser);
}
}
var syncSummary = instance.CheckSync();
List<string> items = new List<string>();
items.AddRange(syncSummary.UpgradedMods.Select(
mod => string.Format ("Upgraded mod: {0} {1}", mod.NewVersion.Name, mod.NewVersion.Version)
));
items.AddRange(syncSummary.AddedMods.Select(
mod => string.Format ("New mod: {0} {1}", mod.Name, mod.Version)
));
items.AddRange(syncSummary.RemovedMods.Select(
mod => string.Format ("Removed mod: {0}", mod.Name)
));
if (syncSummary.NewConfiguration)
items.Add("New configuration to download.");
InstanceName = instance.Description.Name;
Description = instance.Description.Description;
var newDesc = Instance.FetchServerInstanceDescription();
serverNews.Buffer.Text = newDesc.MessageOfTheDay;
//playButton.ImagePosition = PositionType.Left;
if (items.Count > 0) {
UpdateSummary = string.Join("\n", items.Select (x => " * "+x));
playButton.Image = Image.NewFromIconName(Stock.GoUp, IconSize.Button);
playButton.Label = "Update to Play!";
} else {
UpdateSummary = "None, ready to play!";
playButton.Hide();
playButton.Unrealize();
playButton.Label = "Play!";
playButton.Image = Image.NewFromIconName(Stock.Apply, IconSize.Button);
playButton.Show();
}
}
static void Main(string[] args)
{
var vp = new Instance();
vp.Connect();
vp.Login("trooper", "", "jeeves");
vp.Enter("Blizzard");
Console.WriteLine("online");
vp.UpdateAvatar();
vp.UseAutoWaitTimer = true;
vp.OnAvatarEnter += vp_OnAvatarEnter;
vp.OnAvatarChange += vp_OnAvatarChange;
vp.OnChatMessage += vp_OnChatMessage;
while (true) // Loop indefinitely
{
Console.WriteLine("Enter input:"); // Prompt
string line = Console.ReadLine(); // Get string from user
if (line == "exit") // Check string
{
break; // exit program
}
else if (line == "hello") // Check string
{
//test command to show status and see if broken
Console.WriteLine("hello trooper");
}
else if (line == "edit terrain") // Check string
{
//change terrain height to bottom of troopers feet
//feather out from trooper
}
else if (line.StartsWith("say"))
{
vp.Say(line.Remove(0, 4));
Console.WriteLine(line);
}
else if (line == "start city")
{
vp.OnAvatarClick += vp_OnAvatarClick;
vp.Say("everyone has been given guns");
}
else if (line == "list players")
{
Console.WriteLine("\nCapacity: {0}", storage.stats.Capacity);
Console.WriteLine("Count: {0}", storage.stats.Count);
}
else
{
Console.Write("You typed "); // Report output
Console.Write(line.Length); // length of line
Console.WriteLine(" characters and i didnt understand one");
}
}
}
protected void CreateDefaultInstance()
{
Instance = new Instance (new InstanceCreateInfo () {
EnabledExtensionNames = new string [] { "VK_KHR_surface", "VK_KHR_android_surface" },
ApplicationInfo = new ApplicationInfo () {
ApiVersion = Vulkan.Version.Make (1, 0, 0)
}
});
}
public void OnClick(Window mainWindow, Instance instance)
{
Assert.ArgumentNotNull(mainWindow, nameof(mainWindow));
CoreApp.RunApp(ApplicationManager.GetEmbeddedFile(@"MongoDb.WindowsService.Installer.zip", "SIM.Tool.Windows", @"MongoDb.WindowsService.Installer.exe"));
}
public static void WriteError(string s)
{
Instance.WriteErrorIns(s);
}
public static void WriteException(Exception ex, LogFiles lf)
{
Instance.WriteExceptionIns(ex, Instance[lf]);
}
public static void WriteInfo(string s, LogFiles lf)
{
Instance.WriteInfoIns(s, Instance[lf]);
}
public static void WriteInfo(string s)
{
Instance.WriteInfoIns(s);
}
public static void Close()
{
Instance.CloseIns();
}
public static void Enable()
{
Instance.EnableIns();
}
void onError(int errorCode, String errorMessage) => Instance.onErrorCallback(errorCode, errorMessage);
void onReady() => Instance.onHandGestureReady();
public static void RegisterTask(string type, TaskPriority priority, string data)
{
Instance.RegisterTask(type, priority, data);
}
void OnClick(int index, int x, int y) => Instance.behaviourOnClick(index, x, y);
public static void RegisterVirtualPathFactory(IVirtualPathFactory virtualPathFactory)
{
Instance.RegisterVirtualPathFactoryInternal(virtualPathFactory);
}
public int AddRole(RoleInfo role)
{
return(Instance.AddRole(role, true));
}
public void UpdateUserRole(int portalId, int userId, int roleId, RoleStatus status, bool isOwner, bool cancel)
{
UserInfo user = UserController.GetUserById(portalId, userId);
UserRoleInfo userRole = GetUserRole(portalId, userId, roleId);
if (cancel)
{
if (userRole != null && userRole.ServiceFee > 0.0 && userRole.IsTrialUsed)
{
//Expire Role so we retain trial used data
userRole.ExpiryDate = DateTime.Now.AddDays(-1);
userRole.Status = status;
userRole.IsOwner = isOwner;
provider.UpdateUserRole(userRole);
EventLogController.Instance.AddLog(userRole, PortalController.Instance.GetCurrentPortalSettings(), UserController.Instance.GetCurrentUserInfo().UserID, "", EventLogController.EventLogType.USER_ROLE_UPDATED);
}
else
{
//Delete Role
DeleteUserRoleInternal(portalId, userId, roleId);
EventLogController.Instance.AddLog("UserId",
userId.ToString(CultureInfo.InvariantCulture),
PortalController.Instance.GetCurrentPortalSettings(),
UserController.Instance.GetCurrentUserInfo().UserID,
EventLogController.EventLogType.USER_ROLE_DELETED);
}
}
else
{
int UserRoleId = -1;
DateTime ExpiryDate = DateTime.Now;
DateTime EffectiveDate = Null.NullDate;
bool IsTrialUsed = false;
int Period = 0;
string Frequency = "";
if (userRole != null)
{
UserRoleId = userRole.UserRoleID;
EffectiveDate = userRole.EffectiveDate;
ExpiryDate = userRole.ExpiryDate;
IsTrialUsed = userRole.IsTrialUsed;
}
RoleInfo role = Instance.GetRole(portalId, r => r.RoleID == roleId);
if (role != null)
{
if (IsTrialUsed == false && role.TrialFrequency != "N")
{
Period = role.TrialPeriod;
Frequency = role.TrialFrequency;
}
else
{
Period = role.BillingPeriod;
Frequency = role.BillingFrequency;
}
}
if (EffectiveDate < DateTime.Now)
{
EffectiveDate = Null.NullDate;
}
if (ExpiryDate < DateTime.Now)
{
ExpiryDate = DateTime.Now;
}
if (Period == Null.NullInteger)
{
ExpiryDate = Null.NullDate;
}
else
{
switch (Frequency)
{
case "N":
ExpiryDate = Null.NullDate;
break;
case "O":
ExpiryDate = new DateTime(9999, 12, 31);
break;
case "D":
ExpiryDate = ExpiryDate.AddDays(Period);
break;
case "W":
ExpiryDate = ExpiryDate.AddDays(Period * 7);
break;
case "M":
ExpiryDate = ExpiryDate.AddMonths(Period);
break;
case "Y":
ExpiryDate = ExpiryDate.AddYears(Period);
break;
}
}
if (UserRoleId != -1 && userRole != null)
{
userRole.ExpiryDate = ExpiryDate;
userRole.Status = status;
userRole.IsOwner = isOwner;
provider.UpdateUserRole(userRole);
EventLogController.Instance.AddLog(userRole, PortalController.Instance.GetCurrentPortalSettings(), UserController.Instance.GetCurrentUserInfo().UserID, "", EventLogController.EventLogType.USER_ROLE_UPDATED);
}
else
{
AddUserRole(portalId, userId, roleId, status, isOwner, EffectiveDate, ExpiryDate);
}
}
//Remove the UserInfo from the Cache, as it has been modified
DataCache.ClearUserCache(portalId, user.Username);
Instance.ClearRoleCache(portalId);
}
public bool IsVisible(Window mainWindow, Instance instance)
{
return(true);
}
void onHandDetected(AndroidJavaObject hand, bool isHand) => Instance.onHandDetected(hand, isHand);
public bool IsEnabled(Window mainWindow, Instance instance)
{
Assert.ArgumentNotNull(mainWindow, nameof(mainWindow));
return(true);
}
void OnHoldCancel(int index, string handType, int x, int y) => Instance.behaviourOnHoldCancel(index, handType, x, y);
public static void Disable()
{
Instance.DisableIns();
}
void OnGrabCancel(int index, int x, int y, int dx, int dy) => Instance.behaviourOnGrabCancel(index, x, y, dx, dy);
public static void WriteInfo(string s, EPrefix prefix, LogFiles logFiles)
{
Instance.WriteInfoIns(s, prefix, Instance[logFiles]);
}
void OnGrabReplease(int index, int x, int y, int dx, int dy) => Instance.behaviourOnGrabRelease(index, x, y, dx, dy);
public static void WriteInfo(string s, EPrefix prefix)
{
Instance.WriteInfoIns(s, prefix, null);
}
void OnGrabHolding(int index, int x, int y, int dx, int dy) => Instance.behaviourOnGrabHolding(index, x, y, dx, dy);
public static void WriteError(string s, EPrefix prefix)
{
Instance.WriteErrorIns(s, prefix, null);
}
void OnGrabStart(int index, int x, int y) => Instance.behaviourOnGrabStart(index, x, y);
public static void Write(string s, LogFiles logf)
{
Instance.WriteIns(s, Instance[logf]);
}
/// <summary>
/// 获取商品评价
/// </summary>
/// <param name="appId"></param>
/// <param name="commodityId"></param>
/// <returns></returns>
public static BtpScoreDTO GetComFirstScore(Guid appId, Guid commodityId)
{
string lastRecordTime = "9946704778000";
return(toBtpScoreDto(Instance.GetScoreList(appId, commodityId, 5, lastRecordTime, Pager.New, EvaluateType.All)));
}
public override int GetHashCode()
{
return((Instance == null ? 0 : Instance.GetHashCode()) ^ (TargetType == null ? 0 : TargetType.GetHashCode()));
}
public static void WriteException(Exception ex)
{
Instance.WriteExceptionIns(ex);
}
