public static void Run()
{
try
{
const string mailboxUri = "https://exchnage/ews/exchange.asmx";
const string domain = @"";
const string username = @"*****@*****.**";
const string password = @"password";
// ExStart:UpdatUserConfiguration
NetworkCredential credentials = new NetworkCredential(username, password, domain);
IEWSClient client = EWSClient.GetEWSClient(mailboxUri, credentials);
Console.WriteLine("Connected to Exchange 2010");
// Create the User Configuration for Inbox folder
UserConfigurationName userConfigName = new UserConfigurationName("inbox.config", client.MailboxInfo.InboxUri);
UserConfiguration userConfig = new UserConfiguration(userConfigName);
userConfig.Dictionary.Add("key1", "value1");
userConfig.Dictionary.Add("key2", "value2");
userConfig.Dictionary.Add("key3", "value3");
client.CreateUserConfiguration(userConfig);
// ExEnd:UpdatUserConfiguration
}
catch (Exception ex)
{
Console.Write(ex.Message);
}
}
public ConfigManagerImpl( ISharedDictionary dic )
{
_dic = dic;
_dic.Changed += new EventHandler<ConfigChangedEventArgs>( ObjectConfigurationChanged );
_systemConfiguration = new SystemConfiguration( this );
_userConfiguration = new UserConfiguration( this );
_solvedPluginConfiguration = new SolvedPluginConfiguration( this );
}
public void AddToStorage(string i_UniqueName, string i_AccessToken)
{
UserConfiguration UserConfigurationToStore = new UserConfiguration(i_UniqueName, i_AccessToken);
if (!StorageList.Any(name=> name.uniqueName==i_UniqueName))
{
StorageList.Add(UserConfigurationToStore);
if (UserConfigurationsAddedToStorage != null)
{
UserConfigurationsAddedToStorage(UserConfigurationToStore);
}
}
}
internal static UserConfiguration OpenFaiMessage(MailboxSession mailboxSession, string faiMessageClass, bool createIfMissing, StoreId folderId)
{
UserConfiguration userConfiguration = null;
bool flag = true;
int num = 0;
while (flag)
{
flag = false;
Exception ex = null;
try
{
userConfiguration = mailboxSession.UserConfigurationManager.GetFolderConfiguration(faiMessageClass, UserConfigurationTypes.Stream | UserConfigurationTypes.XML | UserConfigurationTypes.Dictionary, folderId);
}
catch (ObjectNotFoundException ex2)
{
ex = ex2;
}
catch (CorruptDataException ex3)
{
ex = ex3;
}
if (userConfiguration == null)
{
ElcMailboxHelper.Tracer.TraceDebug <string, Exception>(0L, "FAI message '{0}' is missing or corrupt. Exception: {1}", faiMessageClass, ex);
if (createIfMissing)
{
if (ex is CorruptDataException)
{
mailboxSession.UserConfigurationManager.DeleteFolderConfigurations(folderId, new string[]
{
faiMessageClass
});
}
try
{
userConfiguration = mailboxSession.UserConfigurationManager.CreateFolderConfiguration(faiMessageClass, UserConfigurationTypes.Stream | UserConfigurationTypes.XML | UserConfigurationTypes.Dictionary, folderId);
}
catch (ObjectExistedException arg)
{
ElcMailboxHelper.Tracer.TraceDebug <string, ObjectExistedException>(0L, "FAI message '{0}' already exists. Exception: {1}", faiMessageClass, arg);
if (num < 1)
{
ElcMailboxHelper.Tracer.TraceDebug <string>(0L, "Try to get or create FAI message '{0}' one more time.", faiMessageClass);
flag = true;
num++;
}
}
}
}
}
return(userConfiguration);
}
public EditPage(UserConfiguration _userConfig, string _uniqueId)
{
InitializeComponent();
DataContext = this;
userConfig = _userConfig;
uniqueId = _uniqueId;
LoadDevice();
LoadPages();
}
private async Task <string> AddVersion(UserConfiguration uc, CancellationToken cancelToken)
{
string versionID = "";
Dictionary <string, string> formParms = new Dictionary <string, string>();
formParms.Add("bundle_version", _appInfo.Version);
FormUrlEncodedContent paramContent = new FormUrlEncodedContent(formParms);
HttpClient client = HttpClientFactory.Create();
client.DefaultRequestHeaders.Add("X-HockeyAppToken", uc.UserToken);
HttpResponseMessage response = await client.PostAsync(uc.ApiBase + "apps/" + _appInfo.PublicID + "/app_versions/new", paramContent, cancelToken);
if (response.StatusCode == HttpStatusCode.Created)
{
StreamContent sr = response.Content as StreamContent;
string result = await sr.ReadAsStringAsync();
JavaScriptSerializer serializer = new JavaScriptSerializer();
dynamic responseInfo = serializer.Deserialize <object>(result);
versionID = ((Dictionary <string, object>)responseInfo)["id"].ToString();
}
else
{
StreamContent sr = response.Content as StreamContent;
string result = await sr.ReadAsStringAsync();
JavaScriptSerializer serializer = new JavaScriptSerializer();
dynamic responseInfo = serializer.Deserialize <object>(result);
Dictionary <string, object> errors = responseInfo["errors"];
StringBuilder message = new StringBuilder();
message.AppendLine(response.ReasonPhrase);
foreach (string key in errors.Keys)
{
object[] values = (object[])errors[key];
string val = "";
foreach (object obj in values)
{
val += obj.ToString() + ", ";
}
if (val.Length > -2)
{
val = val.Substring(0, val.Length - 2);
}
message.AppendLine(key + ":" + val);
}
throw new Exception(message.ToString());
}
return(versionID);
}
// Token: 0x06000F83 RID: 3971 RVA: 0x0005BF6C File Offset: 0x0005A16C
public IPublicFolderSplitState ReadFromStore(out Exception error)
{
IPublicFolderSplitState publicFolderSplitState = null;
error = null;
try
{
using (Folder folder = this.xsoFactory.BindToFolder(this.publicFolderSession, this.publicFolderSession.GetTombstonesRootFolderId()) as Folder)
{
using (UserConfiguration configuration = UserConfiguration.GetConfiguration(folder, new UserConfigurationName("PublicFolderSplitState", ConfigurationNameKind.Name), UserConfigurationTypes.Stream))
{
using (Stream stream = configuration.GetStream())
{
if (stream.Length == 0L)
{
publicFolderSplitState = new PublicFolderSplitState();
}
else
{
try
{
publicFolderSplitState = (SplitStateAdapter.Serializer.ReadObject(stream) as PublicFolderSplitState);
if (publicFolderSplitState == null || publicFolderSplitState.VersionNumber != SplitStateAdapter.CurrentVersion)
{
publicFolderSplitState = new PublicFolderSplitState();
this.logger.LogEvent(LogEventType.Verbose, string.Format("SplitStateAdapter::{0}::ReadFromStore - Unrecognized split state type for {1}", this.GetHashCode(), this.publicFolderSession.DisplayAddress));
}
}
catch (SerializationException arg)
{
publicFolderSplitState = new PublicFolderSplitState();
this.logger.LogEvent(LogEventType.Verbose, string.Format("SplitStateAdapter::{0}::ReadFromStore - Received serialization exception for {1} - {2}", this.GetHashCode(), this.publicFolderSession.DisplayAddress, arg));
}
}
}
}
}
}
catch (StorageTransientException ex)
{
error = ex;
}
catch (StoragePermanentException ex2)
{
error = ex2;
}
if (error != null)
{
this.logger.LogEvent(LogEventType.Verbose, string.Format("SplitStateAdapter::{0}::ReadFromStore - Error reading the split state for {1} - {2}", this.GetHashCode(), this.publicFolderSession.DisplayAddress, error));
}
return(publicFolderSplitState);
}
public IActionResult DownloadDockerfiles(UserConfiguration config)
{
var hs = new HomeControllerService();
this.UploadFile(config);
hs.CreateGamsDockerfile(config);
//hs.CreateModelDockerfile(config);
var dlFile = hs.CreateDockerZipFile();
return(hs.DownloadFile(dlFile, "dockerfile.zip"));
}
void SetPageType(UserConfiguration userConfig)
{
if (userConfig != null)
{
Title = "Edit Account";
Image = new Uri("pack://application:,,,/TrakHound-Dashboard;component/Resources/blank_profile_01_sm.png");
}
else
{
Title = "Create Account";
Image = new Uri("pack://application:,,,/TrakHound-Dashboard;component/Resources/AddUser_01.png");
}
}
public static bool Update(UserConfiguration userConfig, DataTable table)
{
string uniqueId = DataTable_Functions.GetTableValue(table, "address", "/UniqueId", "value");
if (!string.IsNullOrEmpty(uniqueId))
{
var deviceInfo = new DeviceInfo(uniqueId, table);
return(Update(userConfig, deviceInfo));
}
return(false);
}
public static void Seed(AppDbContext context)
{
BehaviourTypeConfiguration.Seed(context);
CardConfiguration.Seed(context);
CardLayoutConfiguration.Seed(context);
FrequencyTypeConfiguration.Seed(context);
UserConfiguration.Seed(context);
TagConfiguration.Seed(context);
DashboardConfiguration.Seed(context);
DashboardCardConfiguration.Seed(context);
}
static void GetUserConfiguration(ExchangeService service)
{
// Binds to an user configuration object. Results in a call to EWS.
UserConfiguration usrConfig = UserConfiguration.Bind(service,
"MyCustomSettingName",
WellKnownFolderName.Inbox,
UserConfigurationProperties.All);
// Display the returned property values.
Console.WriteLine("User Config Identifier: " + usrConfig.ItemId.UniqueId);
Console.WriteLine("XmlData: " + Encoding.UTF8.GetString(usrConfig.XmlData));
Console.WriteLine("BinaryData: " + Encoding.UTF8.GetString(usrConfig.BinaryData));
}
public ActionResult UpdateUserConfiguration(
[FromRoute, Required] Guid userId,
[FromBody] UserConfiguration userConfig)
{
if (!RequestHelpers.AssertCanUpdateUser(_authContext, HttpContext.Request, userId, false))
{
return(Forbid("User configuration update not allowed"));
}
_userManager.UpdateConfiguration(userId, userConfig);
return(NoContent());
}
public static Image DownloadImage(UserConfiguration userConfig, string fileId, bool useCache)
{
Uri uri;
if (Uri.TryCreate(fileId, UriKind.Absolute, out uri))
{
return(DownloadImagev2(uri, useCache));
}
else
{
return(DownloadImagev1(userConfig, fileId, useCache));
}
}
public void Invoke(int projectId, int userId, string name, UserConfiguration configuration)
{
var userCustomData =
userCustomDataRepository.FindBy(
m =>
(m.ProjectCustomData.ProjectId == projectId) && (m.UserId == userId) &&
(m.ProjectCustomData.ConfigurationName == name)).FirstOrDefault() ?? new UserCustomData();
userCustomData.SerializedConfiguration = customDataJsonConvertService.Serialize(configuration);
userCustomData.ModificationDate = DateTime.UtcNow;
userCustomDataRepository.Edit(userCustomData);
}
public static UserConfiguration GetUserConfiguration(string application, string[] usernames)
{
//Get the application configuration for the specified user
UserConfiguration config = null;
try {
config = _Client.GetUserConfiguration(application, usernames);
}
catch (FaultException fe) { throw new ApplicationException("GetUserConfiguration() service error.", fe); }
catch (TimeoutException te) { throw new ApplicationException("GetUserConfiguration() timeout error.", te); }
catch (CommunicationException ce) { throw new ApplicationException("GetUserConfiguration() communication error.", ce); }
return(config);
}
protected override void InternalDelete(ConfigurableObject instance)
{
VersionedXmlConfigurationObject versionedXmlConfigurationObject = (VersionedXmlConfigurationObject)instance;
using (UserConfiguration mailboxConfiguration = UserConfigurationHelper.GetMailboxConfiguration(base.MailboxSession, versionedXmlConfigurationObject.UserConfigurationName, UserConfigurationTypes.XML, false))
{
if (mailboxConfiguration == null)
{
return;
}
}
UserConfigurationHelper.DeleteMailboxConfiguration(base.MailboxSession, versionedXmlConfigurationObject.UserConfigurationName);
}
public async Task <ActionResult> UpdateUserConfiguration(
[FromRoute, Required] Guid userId,
[FromBody, Required] UserConfiguration userConfig)
{
if (!await RequestHelpers.AssertCanUpdateUser(_authContext, HttpContext.Request, userId, false).ConfigureAwait(false))
{
return(StatusCode(StatusCodes.Status403Forbidden, "User configuration update not allowed"));
}
await _userManager.UpdateConfigurationAsync(userId, userConfig).ConfigureAwait(false);
return(NoContent());
}
protected RecipientCache(UserContext userContext, short cacheSize, UserConfiguration configuration)
{
if (userContext == null)
{
throw new ArgumentNullException("userContext");
}
this.userContext = userContext;
this.cacheSize = cacheSize;
this.cacheEntries = new List <RecipientInfoCacheEntry>((int)cacheSize);
if (userContext.CanActAsOwner)
{
this.Load(configuration);
}
}
protected override void InternalSave(ConfigurableObject instance)
{
VersionedXmlConfigurationObject versionedXmlConfigurationObject = (VersionedXmlConfigurationObject)instance;
using (UserConfiguration mailboxConfiguration = UserConfigurationHelper.GetMailboxConfiguration(base.MailboxSession, versionedXmlConfigurationObject.UserConfigurationName, UserConfigurationTypes.XML, true))
{
using (Stream xmlStream = mailboxConfiguration.GetXmlStream())
{
VersionedXmlBase.Serialize(xmlStream, (VersionedXmlBase)versionedXmlConfigurationObject[versionedXmlConfigurationObject.RawVersionedXmlPropertyDefinition]);
}
mailboxConfiguration.Save();
}
instance.ResetChangeTracking();
}
public static List <DeviceDescription> List(UserConfiguration userConfig, string[] deviceUniqueIds, Uri apiHost)
{
if (deviceUniqueIds != null && deviceUniqueIds.Length > 0)
{
string url = new Uri(apiHost, "devices/list/index.php").ToString();
var getDeviceInfos = new List <GetDeviceInfo>();
foreach (var deviceUniqueId in deviceUniqueIds)
{
getDeviceInfos.Add(new GetDeviceInfo(deviceUniqueId));
}
string json = JSON.FromObject(getDeviceInfos);
if (json != null)
{
var postDatas = new NameValueCollection();
if (userConfig != null)
{
postDatas["token"] = userConfig.SessionToken;
postDatas["sender_id"] = UserManagement.SenderId.Get();
}
postDatas["devices"] = json;
string response = HTTP.POST(url, postDatas);
if (response != null)
{
bool success = ApiError.ProcessResponse(response, "List Devices");
if (success)
{
var deviceInfos = JSON.ToType <List <Data.DeviceInfo> >(response);
if (deviceInfos != null)
{
var devices = new List <DeviceDescription>();
foreach (var deviceInfo in deviceInfos)
{
devices.Add(new DeviceDescription(deviceInfo));
}
return(devices);
}
}
}
}
}
return(null);
}
public virtual TModelItem GetModelData()
{
TModelItem tmodelItem = default(TModelItem);
using (UserConfiguration userConfiguration = this.GetUserConfiguration(this.modelFAIName, true))
{
using (Stream modelStreamFromUserConfig = this.GetModelStreamFromUserConfig(userConfiguration))
{
if (modelStreamFromUserConfig.Length == 0L)
{
tmodelItem = Activator.CreateInstance <TModelItem>();
}
else
{
DataContractSerializer serializer = new DataContractSerializer(typeof(TModelItem), MdbPeopleBaseModelDataBinder <TModelItem> .KnownTypesForSerialization);
try
{
tmodelItem = this.ReadModelData(serializer, modelStreamFromUserConfig);
if (tmodelItem == null)
{
this.diagnosticsSession.TraceError("Deserializing the stream returned a type other than inference model item", new object[0]);
tmodelItem = Activator.CreateInstance <TModelItem>();
}
else if (tmodelItem.Version < this.MinimumSupportedVersion)
{
this.diagnosticsSession.TraceDebug <Version>("Returning a new InferenceModelItem since version {0} in the existing model is not supported.", tmodelItem.Version);
tmodelItem = Activator.CreateInstance <TModelItem>();
}
}
catch (SerializationException arg)
{
this.diagnosticsSession.TraceError <SerializationException>("Received serialization exception - {0}", arg);
tmodelItem = Activator.CreateInstance <TModelItem>();
using (this.ResetModel(true))
{
}
}
catch (ArgumentException arg2)
{
this.diagnosticsSession.TraceError <ArgumentException>("Received argument exception - {0}", arg2);
tmodelItem = Activator.CreateInstance <TModelItem>();
using (this.ResetModel(true))
{
}
}
}
}
}
return(tmodelItem);
}
public static void Update(UserConfiguration userConfig, List <Data.DeviceInfo> deviceInfos)
{
if (ApiConfiguration.DataApiHost.ToString() != ApiConfiguration.LOCAL_API_HOST) // Remote
{
var json = Data.DeviceInfo.ListToJson(deviceInfos);
if (json != null)
{
var values = new NameValueCollection();
if (userConfig != null)
{
values["token"] = userConfig.SessionToken;
}
values["sender_id"] = UserManagement.SenderId.Get();
values["devices"] = json;
string url = new Uri(ApiConfiguration.DataApiHost, "data/update/index.php").ToString();
var info = new SendDataInfo(url, values);
ThreadPool.QueueUserWorkItem(new WaitCallback(SendData), info);
}
}
else // Local
{
var json = Data.DeviceInfo.ListToJson(deviceInfos);
if (json != null)
{
var values = new NameValueCollection();
values["devices"] = json;
string url = new Uri(ApiConfiguration.DataApiHost, "data/update/index.php").ToString();
// Send to local server
var info = new SendDataInfo(url, values);
ThreadPool.QueueUserWorkItem(new WaitCallback(SendData), info);
if (userConfig != null)
{
values["token"] = userConfig.SessionToken;
values["sender_id"] = UserManagement.SenderId.Get();
// Send to TrakHound Cloud (for Mobile App)
var cloudUri = new Uri(ApiConfiguration.CLOUD_API_HOST);
url = new Uri(cloudUri, "data/update/index.php").ToString();
var cloudInfo = new SendDataInfo(url, values);
ThreadPool.QueueUserWorkItem(new WaitCallback(SendData), cloudInfo);
}
}
}
}
internal static ConfigurableObject Fill(ConfigurableObject configObject, ProviderPropertyDefinition[] appliedProperties, UserConfigurationDictionaryHelper.GetDictionaryUserConfigurationDelegate getDictionaryUserConfigurationDelegate)
{
Util.ThrowOnNullArgument(configObject, "configObject");
Util.ThrowOnNullArgument(appliedProperties, "appliedProperties");
using (UserConfiguration userConfiguration = getDictionaryUserConfigurationDelegate(false))
{
if (userConfiguration == null)
{
return(null);
}
UserConfigurationDictionaryHelper.Fill(userConfiguration, configObject, appliedProperties);
}
return(configObject);
}
public static UserConfiguration GetUserConfigurationData(bool forceReload, int userId)
{
if (forceReload)
{
log.Debug("Method called with Force Reload");
}
if (theContextConfiguration == null || forceReload)
{
log.Debug("Forcing configuration reload");
theContextConfiguration = GetUserConfigurationData(userId);
}
return(theContextConfiguration);
}
protected override void OnModelCreating(ModelBuilder builder)
{
ExaminationConfiguration.Configure(builder);
UserConfiguration.Configure(builder);
RoleConfiguration.Configure(builder);
ExaminationDetailsDetailsConfiguration.Configure(builder);
QuestionUserAnswerConfiguration.Configure(builder);
PossibleAnswerSelectedConfiguration.Configure(builder);
BuildQuestion(builder);
BuildTest(builder);
base.OnModelCreating(builder);
}
public IHttpActionResult DeleteUserConfiguration(int id)
{
UserConfiguration userConfiguration = db.UserConfigurations.Find(id);
if (userConfiguration == null)
{
return(NotFound());
}
db.UserConfigurations.Remove(userConfiguration);
db.SaveChanges();
return(Ok(userConfiguration));
}
public UserConfiguration GetUserConfig()
{
if (LoadUserSuccess)
{
var userConfig = new UserConfiguration();
foreach (XmlNode configNode in UserConfigNodes.ChildNodes)
{
//EventLogger.WriteLog("CONFIG", string.Format("Found {0} configuration of user: {1}", configNode.Name, configNode.ChildNodes[0].Value.Trim()));
switch (configNode.Name.Trim())
{
case "userPCID":
userConfig.PCID = configNode.ChildNodes[0].Value.Trim();
break;
case "userID":
userConfig.ID = int.Parse(configNode.ChildNodes[0].Value.Trim());
break;
case "userLogPath":
userConfig.LogPath = configNode.ChildNodes[0].Value.Trim();
break;
case "userCheckInterval":
userConfig.CheckInterval = configNode.ChildNodes[0].Value.Trim();
break;
case "userOpenOnStartup":
userConfig.OpenOnStartup = configNode.ChildNodes[0].Value.Trim();
break;
case "userMinimizedWhenClose":
userConfig.MinimizedWhenClose = configNode.ChildNodes[0].Value.Trim();
break;
case "userPreviousPCID":
userConfig.PreviousPCID = configNode.ChildNodes[0].Value.Trim();
break;
default:
EventLogger.WriteLog("ERROR", string.Format("Unknown service attribute \"{0}\" in config file", configNode.ChildNodes[0].Value.Trim()));
break;
}
}
return(userConfig);
}
else
{
return(null);
}
}
static void DeleteUserConfiguration(ExchangeService service)
{
// Binds to an user configuration object. Results in a call to EWS.
UserConfiguration usrConfig = UserConfiguration.Bind(service,
"MyCustomSettingName",
WellKnownFolderName.Inbox,
UserConfigurationProperties.Id);
// Deletes the user configuration object.
// Results in a call to EWS.
usrConfig.Delete();
Console.WriteLine("The user configuration settings have been deleted.");
}
// Note: Accessing hidden folders such as the one for categories is not something which is considered supportable or advised by MS.
public void LoadUserConfigIntoTreeViewNodeCategoryList(ExchangeService service, ref TreeNode oNode, FolderId oFolderId, string sSettingsName)
{
service.ClientRequestId = Guid.NewGuid().ToString(); // Set a new GUID.
UserConfiguration oUserConfiguration = UserConfiguration.Bind(service,
sSettingsName,
oFolderId,
UserConfigurationProperties.XmlData);
TreeNode xNode = null;
xNode = new TreeNode("XmlData");
xNode.Tag = Encoding.UTF8.GetString(oUserConfiguration.XmlData);
oNode.Nodes.Add(xNode);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddControllers();
UserConfiguration _config = new UserConfiguration();
Configuration.Bind(_config);
services.AddSingleton(_config);
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new OpenApiInfo {
Title = "AspnetCoreSession7.Endpoints.WebUi", Version = "v1"
});
});
}
// GET: UserConfigurationsViews/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
UserConfiguration userConfiguration = db.UserConfigurations.Find(id);
if (userConfiguration == null)
{
return(HttpNotFound());
}
return(View(userConfiguration));
}
public IActionResult BuildImage(UserConfiguration config, string imageName = "")
{
// https://docs.docker.com/engine/reference/builder/
var hs = new HomeControllerService();
hs.CreateGamsDockerfile(config);
if (imageName == string.Empty)
{
imageName = config.SelectedProgram + config.SelectedGithubRepository +
DateTime.Now.ToShortDateString().Replace(".", string.Empty);
}
imageName = imageName.ToLower() + Guid.NewGuid().ToString().Substring(0, 4);
var outputPath = Path.GetFullPath(HomeControllerService.OutputFilePath); //"./Output/");
var files = Directory.GetFiles(outputPath);
var dockerfile = Path.GetFileName(files.FirstOrDefault(file => file.ToLower().Contains("docker")));
if (!string.IsNullOrEmpty(dockerfile))
{
var process = new Process();
var startInfo = new ProcessStartInfo
{
//WindowStyle = ProcessWindowStyle.Hidden,
FileName = "/bin/bash",
Arguments =
$@"docker build -t webinterface/{imageName} - < /app/Output/{
HomeControllerService.OutputFolderName
}/{dockerfile}",
//Arguments = $@"docker build -t test/{imageName} Dockerfile-model",
RedirectStandardOutput = true
};
process.StartInfo = startInfo;
process.Start(); // no such file or directory
Logger.Log(process.StandardOutput.ReadToEnd());
process.WaitForExit();
}
return(this.View("Index", config));
// Todo: Get user info: dockerfile not available
}
public static extern bool WTSSetUserConfig(
IntPtr pServerName,
IntPtr pUserName,
UserConfiguration WTSConfigClass,
IntPtr pBuffer,
long DataLength);
public UserViewModel(UserConfiguration userConfiguration)
{
UserConfiguration = userConfiguration;
}
protected Agent(UserConfiguration ic_configuration)
{
id = ic_configuration.ConfigurationId.Id;
DisplayName = ic_configuration.ConfigurationId.DisplayName;
configuration = ic_configuration;
}
public static extern bool WTSQueryUserConfig(
IntPtr pServerName,
IntPtr pUserName,
UserConfiguration WTSConfigClass,
IntPtr ppBuffer,
IntPtr pBytesReturned);
