public virtual OperationResponse HandleSettingsRequest(OperationRequest operationRequest, SendParameters sendParameters)
{
var request = new SettingsRequest(this.Protocol, operationRequest);
if (!request.IsValid)
{
var msg = string.Format("HandleSettingsRequest error: {0}", request.GetErrorMessage());
if (log.IsWarnEnabled)
{
log.Warn(msg);
}
return(new OperationResponse(operationRequest.OperationCode)
{
DebugMessage = msg,
ReturnCode = (short)ErrorCode.OperationInvalid,
});
}
if (request.ReceiveLobbyStatistics.HasValue)
{
// check if the peer wants to receive lobby statistic events
if (request.ReceiveLobbyStatistics.Value)
{
this.Application.LobbyStatsPublisher.Subscribe(this);
}
else
{
this.Application.LobbyStatsPublisher.Unsubscribe(this);
}
}
return(null);
}
public override async Task LoadSitesList(SettingsRequest request,
Grpc.Core.IServerStreamWriter <Settings> responseStream,
Grpc.Core.ServerCallContext context)
{
List <Settings> responses = null;
string userid = request.Userid;
List <String> settings = db.GetUserSettings(userid, "site");
foreach (var setting in settings)
{
await responseStream.WriteAsync(new Settings { Userid = userid, Field = setting });
}
Console.WriteLine("\nSettings sent to client. Userid: " + userid);
//responses.Add();
//лямбдой
//responses = db.GetUserSettings(userid, "site").Cast<List<Settings>>(){ new Settings { }};
//settings.FindAll((feature) => feature.Exists() && request.Contains(feature.Location));
//получаем из бд настройки для конкретного пользователя
//foreach (var response in responses)
//{
// await responseStream.WriteAsync(response);
//}
}
public object Post(SettingsRequest request)
{
var configStore = GetConfigurationStorage();
if (configStore == null)
{
return(ServerError("No Configuration is available"));
}
var config = configStore.Load();
if (config == null)
{
return(ServerError("Error attempting to load configuration."));
}
try
{
config.PollingFrequency = request.PollingFrequency;
config.EarliestSyncDate = request.EarliestSyncDate;
configStore.Save(config);
}
catch (Exception ex)
{
return(ServerError("An unexpected error occurred while attempting to save changes: " + ex.Message));
}
return(OK());
}
/// <summary>
/// Supports get and set operations on global properties and Out of Office (OOF) settings for the user, sends device information to the server, implements the device password/personal identification number (PIN) recovery, and retrieves a list of the user's e-mail addresses.
/// </summary>
/// <param name="request">A SettingsRequest object that contains the request information.</param>
/// <returns>Settings command response</returns>
public SettingsResponse Settings(SettingsRequest request)
{
SettingsResponse response = this.activeSyncClient.Settings(request);
this.VerifyTransportRequirements();
this.VerifyWBXMLCapture(CommandName.Settings, response);
this.VerifySettingsCommand(response);
return(response);
}
public void OnSaveSettings()
{
RestClient client = new RestClient($"http://{ServerName}");
RestRequest req = new RestRequest("/settings", Method.POST);
var settings_req = new SettingsRequest();
settings_req.temp_threshold = TempThreshold;
settings_req.humidity_threshold = HumidityThreshold;
req.AddJsonBody(settings_req);
var response = client.Execute(req);
}
private void ReceiveSettingsRequest(byte[] body, ulong senderId)
{
Log.Trace("Receiving Settings Request", "ReceiveConcealRequest");
SettingsRequest request = SettingsRequest.FromBytes(body);
SettingsResponse response = new SettingsResponse()
{
Settings = Settings.Instance
};
response.SendToPlayer(senderId);
}
public Task <SettingsResponse> UpdateSettings(SettingsRequest settingsRequest)
{
var options = new AjaxOptions
{
Url = $"{this._settings.ApiUri}/user",
Type = "PUT",
DataType = "json",
ContentType = "application/json",
Data = JsonConvert.SerializeObject(settingsRequest)
};
return(base.MakeAuthorizedCall <SettingsResponse>(options));
}
public IGetResponse GetSetting([FromContent] SettingsRequest Setting)
{
var validate = ap.ValidateAPI(Setting.API.Token, Setting.API.ApiKey, "/settings/get");
if (validate.Code == 0)
{
var set = db.GetSetting(Setting.Setting);
return(new GetResponse(GetResponse.ResponseStatus.OK, null, set));
}
else
{
return(new GetResponse(GetResponse.ResponseStatus.NotFound, null, validate));
}
}
public IPostResponse SaveSetting([FromContent] SettingsRequest Setting)
{
var validate = ap.ValidateAPI(Setting.API.Token, Setting.API.ApiKey, "/settings/save");
if (validate.Code == 0)
{
db.SaveSetting(Setting.Setting);
return(new PostResponse(PostResponse.ResponseStatus.Created, null, new ResponseData {
Code = 0, Message = "Setting saved"
}));
}
else
{
return(new PostResponse(PostResponse.ResponseStatus.Conflict, null, validate));
}
}
public void ShowSettings()
{
if (CheckHasUncommittedChanges())
{
return;
}
ISettingsViewModel confirmation = ServiceLocator.Current.TryResolve <ISettingsViewModel>();
SettingsRequest.Raise(confirmation);
if (!confirmation.Confirmed)
{
return;
}
TestsToCommitCount = 0;
configSerializer.SaveConfig(confirmation.Config);
UpdateConfig();
}
/// <summary>
/// Gets the RightsManagementInformation by Settings command.
/// </summary>
/// <returns>The Settings response which is returned from server.</returns>
public SettingsResponse Settings()
{
SettingsRequest request = new SettingsRequest();
Request.SettingsRightsManagementInformation settingsInformation = new Request.SettingsRightsManagementInformation();
Request.SettingsUserInformation setUser = new Request.SettingsUserInformation {
Item = string.Empty
};
settingsInformation.Get = string.Empty;
request.RequestData.RightsManagementInformation = settingsInformation;
request.RequestData.UserInformation = setUser;
SettingsResponse response = this.activeSyncClient.Settings(request);
Site.Assert.IsNotNull(response, "If the command is successful, the response should not be null.");
this.VerifyWBXMLCapture();
this.VerifySettingsResponse(response);
return(response);
}
public void MSASHTTP_S01_TC13_CommandCode_UserRelatedCommands()
{
#region Call ResolveRecipients command.
object[] items = new object[] { Common.GetConfigurationPropertyValue("User1Name", Site) };
ResolveRecipientsRequest resolveRecipientsRequest = Common.CreateResolveRecipientsRequest(items);
SendStringResponse resolveRecipientsResponse = HTTPAdapter.HTTPPOST(CommandName.ResolveRecipients, null, resolveRecipientsRequest.GetRequestDataSerializedXML());
// Check the command is executed successfully.
this.CheckResponseStatus(resolveRecipientsResponse.ResponseDataXML);
#endregion
#region Call Settings command.
SettingsRequest settingsRequest = Common.CreateSettingsRequest();
SendStringResponse settingsResponse = HTTPAdapter.HTTPPOST(CommandName.Settings, null, settingsRequest.GetRequestDataSerializedXML());
// Check the command is executed successfully.
this.CheckResponseStatus(settingsResponse.ResponseDataXML);
#endregion
}
public async Task <IHttpActionResult> UpdateSettingAsync(SettingsRequest request)
{
var response = new SettingsResponse();
var accountId = Identity.ToAccountID();
if (request.SettingViewModel.AccountId != accountId)
{
response.ErrorMessage = "Not permissions";
response.StatusCode = (int)HttpStatusCode.Forbidden;
}
else
{
await _settingService.UpdateSettingAsync(request.SettingViewModel);
response.StatusCode = (int)HttpStatusCode.OK;
}
return(Ok(response));
}
public IActionResult UpdateSettings([FromBody] SettingsRequest request)
{
var type = typeof(SettingsKeyAttribute).Assembly.GetTypes().FirstOrDefault(t => t.GetCustomAttribute <SettingsKeyAttribute>()?.Key == request.Key);
if (type == null)
{
return(BadRequest("Unknown key"));
}
var settings = settingsRepository.GetSettings(CurrentUserId, request.Key);
if (settings == null)
{
settings = SettingsUtils.CreateDefault(request.Key);
}
SettingsUtils.Merge(settings, request.Data);
settingsRepository.UpdateSettings(CurrentUserId, request.Key, settings);
return(Ok());
}
private async Task UpdateSettings()
{
try
{
var settingsRequest = new SettingsRequest
{
Username = this.Username.Self(),
NewPassword = this.NewPassword.Self(),
Biography = this.Biography.Self(),
Email = this.Email.Self(),
ImageUri = this.ImageUri.Self()
};
var userUpdated = await this._settingsResources.UpdateSettings(settingsRequest);
this._navigator.Navigate(SpafApp.ProfileId);
}
catch (PromiseException e)
{
var errors = e.GetValidationErrors();
this.Errors.push(errors.ToArray());
}
}
public IChoicePostRequestWithRetry <Response <List <Setting> >, NetworkError> TryToGetGetSettingsForCodesRequestServer(SettingsRequest data)
{
var urlBuilder = CreateUrlBuilderTryToGetGetSettingsForCodesRequestServer();
return(serverConfig.TryToPost <SettingsRequest, Response <List <Setting> > >(urlBuilder, data));
}
/// <summary>
/// Get OOF settings
/// </summary>
/// <returns>The OOF setting response</returns>
protected SettingsResponse GetOofSettings()
{
SettingsRequest settingsRequest = new SettingsRequest
{
RequestData = new Request.Settings
{
Oof = new Request.SettingsOof { Item = new Request.SettingsOofGet { BodyType = "TEXT" } }
}
};
SettingsResponse settingsResponse = this.CMDAdapter.Settings(settingsRequest);
return settingsResponse;
}
public async Task <ActionResult <SettingsResult> > Settings([FromBody] SettingsRequest request)
{
if (!await _authManager.HasSitePermissionsAsync(request.Settings.SiteId, MenuUtils.SitePermissions.Templates))
{
return(Unauthorized());
}
if (_settingsManager.IsSafeMode)
{
return(this.Error(Constants.ErrorSafeMode));
}
var site = await _siteRepository.GetAsync(request.Settings.SiteId);
if (site == null)
{
return(NotFound());
}
if (request.Settings.TemplateType != TemplateType.ChannelTemplate)
{
if (!request.Settings.CreatedFileFullName.StartsWith("~") && !request.Settings.CreatedFileFullName.StartsWith("@"))
{
request.Settings.CreatedFileFullName = PageUtils.Combine("@", request.Settings.CreatedFileFullName);
}
}
else
{
request.Settings.CreatedFileFullName = request.Settings.CreatedFileFullName.TrimStart('~', '@');
request.Settings.CreatedFileFullName = request.Settings.CreatedFileFullName.Replace("/", string.Empty);
}
Template template;
if (request.Settings.TemplateId > 0)
{
var templateId = request.Settings.TemplateId;
template = await _templateRepository.GetAsync(templateId);
if (template.TemplateName != request.Settings.TemplateName)
{
var templateNameList = await _templateRepository.GetTemplateNamesAsync(request.Settings.SiteId, template.TemplateType);
if (templateNameList.Contains(request.Settings.TemplateName))
{
return(this.Error("模板修改失败，模板名称已存在！"));
}
}
Template previousTemplate = null;
var isChanged = false;
if (PathUtils.RemoveExtension(template.RelatedFileName) != PathUtils.RemoveExtension(request.Settings.RelatedFileName))//文件名改变
{
var fileNameList = await _templateRepository.GetRelatedFileNamesAsync(request.Settings.SiteId, template.TemplateType);
foreach (var fileName in fileNameList)
{
var fileNameWithoutExtension = PathUtils.RemoveExtension(fileName);
if (StringUtils.EqualsIgnoreCase(fileNameWithoutExtension, request.Settings.RelatedFileName))
{
return(this.Error("模板修改失败，模板文件已存在！"));
}
}
isChanged = true;
}
if (GetTemplateFileExtension(template) != request.Settings.CreatedFileExtName)//文件后缀改变
{
isChanged = true;
}
if (isChanged)
{
previousTemplate = new Template
{
Id = template.Id,
SiteId = template.SiteId,
TemplateName = template.TemplateName,
TemplateType = template.TemplateType,
RelatedFileName = template.RelatedFileName,
CreatedFileFullName = template.CreatedFileFullName,
CreatedFileExtName = template.CreatedFileExtName,
DefaultTemplate = template.DefaultTemplate
};
}
template.TemplateName = request.Settings.TemplateName;
template.RelatedFileName = request.Settings.RelatedFileName + request.Settings.CreatedFileExtName;
template.CreatedFileExtName = request.Settings.CreatedFileExtName;
template.CreatedFileFullName = request.Settings.CreatedFileFullName + request.Settings.CreatedFileExtName;
template.Content = request.Content;
await _pathManager.WriteContentToTemplateFileAsync(site, template, request.Content, _authManager.AdminId);
await _templateRepository.UpdateAsync(template);
if (previousTemplate != null)
{
FileUtils.DeleteFileIfExists(await _pathManager.GetTemplateFilePathAsync(site, previousTemplate));
}
await _authManager.AddSiteLogAsync(request.Settings.SiteId,
$"修改{template.TemplateType.GetDisplayName()}",
$"模板名称:{template.TemplateName}");
}
else
{
var templateNameList = await _templateRepository.GetTemplateNamesAsync(request.Settings.SiteId, request.Settings.TemplateType);
if (templateNameList.Contains(request.Settings.TemplateName))
{
return(this.Error("模板添加失败，模板名称已存在！"));
}
var fileNameList = await _templateRepository.GetRelatedFileNamesAsync(request.Settings.SiteId, request.Settings.TemplateType);
if (ListUtils.ContainsIgnoreCase(fileNameList, request.Settings.RelatedFileName))
{
return(this.Error("模板添加失败，模板文件已存在！"));
}
template = new Template
{
SiteId = request.Settings.SiteId,
TemplateName = request.Settings.TemplateName,
TemplateType = request.Settings.TemplateType,
RelatedFileName = request.Settings.RelatedFileName + request.Settings.CreatedFileExtName,
CreatedFileExtName = request.Settings.CreatedFileExtName,
CreatedFileFullName = request.Settings.CreatedFileFullName + request.Settings.CreatedFileExtName,
DefaultTemplate = false
};
template.Id = await _templateRepository.InsertAsync(template);
await _authManager.AddSiteLogAsync(request.Settings.SiteId,
$"添加{template.TemplateType.GetDisplayName()}",
$"模板名称:{template.TemplateName}");
await _pathManager.WriteContentToTemplateFileAsync(site, template, request.Content, _authManager.AdminId);
}
var settings = await GetSettingsAsync(template, site);
return(new SettingsResult
{
Settings = settings
});
}
/// <summary>
/// Create one OOF request with empty Settings
/// </summary>
/// <returns>The OOF settings request</returns>
protected static SettingsRequest CreateDefaultOofRequest()
{
SettingsRequest settingsRequest = new SettingsRequest
{
RequestData = new Request.Settings { Oof = new Request.SettingsOof() }
};
return settingsRequest;
}
private void OpenSettings() => SettingsRequest.Raise(new Notification {
Content = "Blank", Title = "Blank"
});
SettingsResponse IEasConnection.Settings(SettingsRequest settingsRequest)
{
throw new NotImplementedException();
}
public object Post(SettingsRequest request)
{
var configStore = GetConfigurationStorage();
if (configStore == null) return ServerError("No Configuration is available");
var config = configStore.Load();
if (config == null) return ServerError("Error attempting to load configuration.");
try
{
config.PollingFrequency = request.PollingFrequency;
config.EarliestSyncDate = request.EarliestSyncDate;
configStore.Save(config);
}
catch (Exception ex)
{
return ServerError("An unexpected error occurred while attempting to save changes: " + ex.Message);
}
return OK();
}
SettingsResponse IEasConnection.Settings(SettingsRequest settingsRequest)
{
SettingsCommand settingsCommand = new SettingsCommand(this.EasConnectionSettings);
return(settingsCommand.Execute(settingsRequest));
}
/// <summary>
/// Create an empty SettingsRequest instance
/// </summary>
/// <returns>An empty SettingsRequest instance</returns>
public static SettingsRequest CreateSettingsRequest()
{
SettingsRequest request = new SettingsRequest();
Request.Settings requestData = new Request.Settings();
request.RequestData = requestData;
return request;
}
