public FormLogin(FormInfo frmInfo, RestController<SessionInformation> rss )
{
_ssi = null;
_rss = rss;
_launcher = frmInfo;
_months = new List<string>() {
"",
"Januari",
"Februari",
"Maret",
"April",
"Mei",
"Juni",
"Juli",
"Agustus",
"September",
"November",
"Oktober",
"November",
"Desember"
};
_days = new List<string>(){
"Minggu",
"Senin",
"Selasa",
"Rabu",
"Kamis",
"Jumat",
"Sabtu",
};
_frmAdmin = new FormAdmin();
InitializeComponent();
}
/// <summary>
/// Generates action descriptor from controller
/// </summary>
/// <param name="controller"></param>
/// <returns></returns>
public ActionDescriptor GenerateActionDescriptor(RestController controller)
{
var actionDescriptor = new ActionDescriptor(controller.Route.ActionName);
var action = GetActionMethodInfo(controller, actionDescriptor.ActionName);
if (action == null)
return null;
MapActionParameters(actionDescriptor, action);
return actionDescriptor;
}
/// <summary>
/// Envía un mensaje por HTTP
/// </summary>
internal ResponseMessage Send(RestController objController, RequestMessage objRequest)
{
ResponseMessage objResult;
HttpWebRequest objHttpRequest = System.Net.WebRequest.Create(objRequest.GetUrlWithQueryString(true)) as HttpWebRequest;
byte[] arrBytPostData;
// Asigna el delegado que trata los errores de certificados en conexiones SSL
ServicePointManager.ServerCertificateValidationCallback =
delegate(object objSender, X509Certificate objCertificate,
X509Chain objChain, SslPolicyErrors objSslPolicyErrors)
{ return true; // ... descarta todos los errores
};
// Añade el certificado si es necesario
if (!string.IsNullOrEmpty(objController.CertificateFileName))
objHttpRequest.ClientCertificates.Add(new X509Certificate2(objController.CertificateFileName));
// Asigna el proxy
if (objController.Proxy.Enabled)
{ // Crea el proxy
objHttpRequest.Proxy = new WebProxy(objController.Proxy.Address, objController.Proxy.MustBypassLocal);
// Asigna las credenciales del proxy
if (!string.IsNullOrEmpty(objController.Proxy.User))
objHttpRequest.Proxy.Credentials = new NetworkCredential(objController.Proxy.User, objController.Proxy.Password);
else
objHttpRequest.UseDefaultCredentials = true;
}
// Asigna las propiedades
objHttpRequest.Method = objRequest.MethodDescription;
objHttpRequest.ServicePoint.Expect100Continue = false;
if (objRequest.Method == RequestMessage.MethodType.Post || objRequest.Method == RequestMessage.MethodType.Put)
objHttpRequest.SendChunked = true;
objHttpRequest.UserAgent = objController.UserAgent;
objHttpRequest.Timeout = objController.TimeOut;
objHttpRequest.KeepAlive = true;
// Procesa la autentificación
if (objController.Authenticator != null)
objController.Authenticator.Process(objRequest);
// Asigna el content-type de la solicitud
if (!objRequest.ContentType.IsEmpty())
objHttpRequest.ContentType = objRequest.ContentType;
// Obtiene los datos a enviar
arrBytPostData = GetPostData(objHttpRequest, objRequest);
// Añade la longitud
if (arrBytPostData != null)
objHttpRequest.ContentLength = arrBytPostData.Length;
// Asigna las cabeceras
AddHeaders(objHttpRequest, objRequest.Headers);
// Escribe los datos
WritePostData(objHttpRequest, arrBytPostData);
// Obtiene los datos de la respuesta
objResult = GetResponse(objHttpRequest);
// Cierra la solicitud Web
objHttpRequest = null;
// Devuelve los datos de salida
return objResult;
}
/// <summary>
/// Saves item data
/// </summary>
/// <param name="item"><see cref="Item"/> object</param>
/// <returns>(<see cref="Item"/>) Item object</returns>
public static Item SaveItem(Item item)
{
item.UpdateDate = DateTime.MaxValue.ToString("yyyy-MM-ddTHH:mm:ss");
var resp = RestController.HttpRequestJson(UriCxm.Items + $@"/{item.Id}", Method.POST, item);
item = JsonConvert.DeserializeObject <Item>(resp.Content);
if (item == null)
{
return(null);
}
SetTitle(item);
return(item);
}
/// <summary>
/// Creates a new place iOS Device with or without a child
/// </summary>
/// <param name="isAssignDevice">Whether iOS device should be assigned to the new place(s) (optional)</param>
/// <param name="isAddChild">Whether child place should be added or not (optional)</param>
/// <returns>(<see cref="Place"/>) New parent place object</returns>
public static Place CreateNewPlaceIos(bool isAssignDevice = false, bool isAddChild = false)
{
var bodyObject = new Place
{
DeviceTypeId = (int)PlaceType.IosDevice,
Id = null,
PlaceModules = new List <PlaceModule>
{
new PlaceModule
{
ModuleId = (int)PlaceType.Ww,
Configuration = JsonConvert.SerializeObject(
new Configuration
{
apps = new List <string>()
})
}
},
ChildPlaces = new List <ChildPlace>(),
DirectItems = new List <DirectItem>(),
Title = $"Auto test {ActionManager.RandomNumber}",
Schedule = new Schedule
{
PlaceId = null,
ScheduleApps = new List <ScheduleApp>()
},
TimeZoneId = 8,
Radius = 5,
Status = (int)PlaceStatus.Active
};
if (isAssignDevice)
{
bodyObject.Device = GetIosDevice();
}
var response = RestController.HttpRequestJson(string.Format(UriCxm.PlacesById, "null"), Method.POST, bodyObject);
var parentPlace = JsonConvert.DeserializeObject <Place>(response.Content);
if (isAddChild)
{
var childPlace = bodyObject;
childPlace.Title = $"Auto test {ActionManager.RandomNumber}";
childPlace.ParentId = parentPlace.Id;
RestController.HttpRequestJson(string.Format(UriCxm.PlacesById, "null"), Method.POST, childPlace);
}
parentPlace = GetById(parentPlace.Id);
return(parentPlace);
}
/// <summary>
/// Añade los nodos de contexto
/// </summary>
private void AddNodesContext(MLNode objMLNode, RestController objContext)
{
MLNode objMLChild = objMLNode.Nodes.Add(cnstStrTagContext);
// Añade los nodos de contexto
objMLChild.Nodes.Add(cnstStrTagContextUserAgent, objContext.UserAgent);
objMLChild.Nodes.Add(cnstStrTagContextTimeOut, objContext.TimeOut);
objMLChild.Nodes.Add(cnstStrTagContextProxyEnabled, objContext.Proxy.Enabled);
objMLChild.Nodes.Add(cnstStrTagContextProxyAddress, objContext.Proxy.Address);
objMLChild.Nodes.Add(cnstStrTagContextProxyPort, objContext.Proxy.Port);
objMLChild.Nodes.Add(cnstStrTagContextProxyUser, objContext.Proxy.User);
objMLChild.Nodes.Add(cnstStrTagContextProxyPassword, objContext.Proxy.Password);
objMLChild.Nodes.Add(cnstStrTagContextProxyByPassLocal, objContext.Proxy.MustBypassLocal);
}
/// <summary>
/// Returns user role data by its ID
/// </summary>
/// <param name="id">Role ID</param>
/// <returns>(<see cref="Role"/>) Role object</returns>
public static Role GetRole(long?id)
{
if (!id.HasValue)
{
return(null);
}
var response = RestController.HttpRequestForm(
TestConfig.UserDirectoryBaseUrlApi + string.Format(UriUserDirectory.RoleById, id),
Method.GET,
Headers);
var roleObject = JsonConvert.DeserializeObject <RoleModel>(response)?.Model;
return(roleObject);
}
/// <summary>
/// Rejects uploaded entity (item or app)
/// </summary>
/// <typeparam name="T">Entity type (see <see cref="IApprovalEntity"/>)</typeparam>
/// <param name="entity">Entity object that should be rejected</param>
/// <returns>()</returns>
public static T Reject <T>(T entity) where T : class, IApprovalEntity
{
var body = GetIdAndType(entity);
body.Action = ApprovalConclusions.Reject.ToString();
body.Comments = string.Empty;
RestController.HttpRequestJson(UriCxm.Approve, Method.POST, body, user: TestConfig.AdminUser);
return((T)Convert.ChangeType(
body.EntityType == (int)ApprovalEntities.Item
? ItemApi.GetById(body.EntityId)
: (object)AppApi.GetById((long)body.EntityId),
typeof(T)));
}
/// <summary>
/// Returns collection of titles of all supported permissions for CX Manager application
/// (except unnecessary ones)
/// </summary>
/// <returns>(<see cref="ICollection{String}"/>) Collection of titles</returns>
public static string[] GetSupportedPermissions()
{
var appId = GetApplicationProperties(SidsTenants.CxmApplicationName).ApplicationId;
var response = RestController.HttpRequestForm(
string.Format(TestConfig.UserDirectoryBaseUrlApi + UriUserDirectory.GetSupportedPermissions, appId),
Method.GET,
Headers);
var permissions = JsonConvert.DeserializeObject <List <Permission> >(response);
return(permissions
.Select(x => x.Key)
.Where(x => !x.Equals("RealFakeSmartdata") && !x.Equals("ComposerLivePreview"))
.ToArray());
}
public void Setup(string id, int amount)
{
restController = GameObject.FindObjectOfType <RestController>();
this.id = id;
foreach (Item item in restController.AvailableItems())
{
if (item.id.Equals(id))
{
nameText.text = item.name;
amountText.text = amount.ToString();
break;
}
}
}
public void GetRequestBodyAsync_ThrowsException_WhenMethod_Is_Null()
{
var controller = new RestController(_loggerMock.Object, _anonymousServiceClientMock.Object, _authenticatedServiceClientMock.Object, _cacheMock.Object);
var type = typeof(BaseActionApiController);
var method = type
.GetMethods(BindingFlags.NonPublic | BindingFlags.Instance)
.First(x => x.Name == "GetRequestBodyAsync" && x.IsPrivate);
Assert.ThrowsAsync <ArgumentNullException>(() =>
(Task <string>)method.Invoke(controller, new object[] { null, null })
);
}
/// <summary>
/// Exports all entities from current tenant (see <see cref="ActionManager.CurrentTenant"/>)
/// </summary>
/// <returns>(<see cref="string"/>) Exported ZIP file name that is saved in <see cref=
/// "TestConfig.BrowserDownloadFolder"/> folder</returns>
public static string ExportTenant()
{
var response = RestController.HttpRequestJson(UriCxm.TenantsExport, Method.GET);
var objList = JsonConvert.DeserializeObject <EntitiesListInfo>(response.Content);
var entitiesIdList = new EntitiesListId();
entitiesIdList.Apps.AddRange(objList.Apps.Select(x => x.Id));
entitiesIdList.Items.AddRange(objList.Items.Select(x => x.Id));
entitiesIdList.Places.AddRange(objList.Places.Select(x => x.Id));
//entitiesIdList.SourceId = "xxx";
response = RestController.HttpRequestJson(UriCxm.TenantsExport, Method.POST, entitiesIdList);
var task = JsonConvert.DeserializeObject <BackgroundTask>(response.Content);
if (task == null || string.IsNullOrEmpty(task.TaskId))
{
throw new Exception(
$"Could not start new background task for tenant '{ActionManager.CurrentTenant}' export");
}
BackgroundTaskApi.ProcessedObjects.AddOrUpdate(task.TaskId,
(null, null, new ManualResetEvent(false)),
(k, v) => (null, null, new ManualResetEvent(false)));
Trace.TraceInformation($"Tenant API: Export task {task.TaskId} started");
string sas, fileName;
if (BackgroundTaskApi.ProcessedObjects.TryGetValue(task.TaskId, out var tenantObj) &&
tenantObj.Item3.WaitOne(TimeSpan.FromSeconds(TestConfig.TenantExportTimeout)))
{
var obj = tenantObj.Item1 as BackgroundTask;
sas = obj?.FileSas;
fileName = obj?.FileName;
Trace.TraceInformation($"Tenant API: Export task {task.TaskId} complete");
}
else
{
Trace.TraceError($"Tenant API: {task.TaskId} export timed out!");
BackgroundTaskApi.DeleteTaskId(task.TaskId);
throw new TimeoutException(
$"Tenant API: Export from tenant {ActionManager.CurrentTenantCode} timed out after " +
$"{TestConfig.TenantExportTimeout} s.");
}
FileManager.Download(sas, fileName);
BackgroundTaskApi.ProcessedObjects.TryRemove(task.TaskId, out _);
BackgroundTaskApi.DeleteTaskId(task.TaskId);
return(fileName);
}
public void GetSoapActionHeader_ReturnsEmptyForNullHttpRequest()
{
var controller = new RestController(_loggerMock.Object, _anonymousServiceClientMock.Object, _authenticatedServiceClientMock.Object, _cacheMock.Object);
var type = typeof(BaseActionApiController);
var method = type
.GetMethods(BindingFlags.NonPublic | BindingFlags.Instance)
.First(x => x.Name == "GetSoapActionHeader" && x.IsPrivate);
var result = (string)method.Invoke(controller, new object[] { null });
Assert.True(string.IsNullOrWhiteSpace(result.ToString()));
}
public static void Run(RestController client, string RestHomeUri, string filter, int itemsPerPage, bool pauseBetweenPages, string repositoryName, bool printResult, string userName)
{
// get repository resource
HomeDocument home = client.Get <HomeDocument>(RestHomeUri, null);
Feed <Repository> repositories = home.GetRepositories <Repository>(new FeedGetOptions {
Inline = true, Links = true
});
Repository repository = repositories.FindInlineEntry(repositoryName);
// get a collection of users
GetUsers(repository, filter, itemsPerPage, pauseBetweenPages, printResult);
OperationsOnUser(repository, userName, itemsPerPage, pauseBetweenPages, printResult);
}
/// <summary>
///
/// </summary>
/// <param name="client"></param>
/// <param name="RestHomeUri"></param>
/// <param name="repositoryName"></param>
/// <param name="printResult"></param>
/// <param name="path"></param>
/// <param name="ThreadNum"></param>
/// <param name="numDocs"></param>
public UseCaseTests(RestController client, string RestHomeUri, string repositoryName, bool printResult, bool pauseBetweenOperations, string path, int ThreadNum, int numDocs)
{
this.client = client;
this.RestHomeUri = RestHomeUri;
this.repositoryName = repositoryName;
this.printResult = printResult;
this.tempPath = path;
this.threadNum = ThreadNum;
this.numDocs = numDocs;
this.pauseBetweenOperations = pauseBetweenOperations;
this.testStart = DateTime.Now;
this.testPrefix = testStart.ToString("yyyyMMddhhmmss") + "-" + threadNum;
this.parentFolderId = "PARENT-" + testPrefix; // new Random().Next(0, 5); ;
client.Logger = new LoggerFacade("RestServices", "NA", parentFolderId, parentFolderId);
}
/// <summary>
/// Envía los datos
/// </summary>
private void Send()
{
if (ValidateData())
{
RestController objRestController = new RestController();
// Asigna el proxy
AssignContext(objRestController);
// Ejecuta las instrucciones
foreach (Projects.Instruction objInstruction in objProject.Instructions)
{
ShowResponse(objRestController.Send(objInstruction.Request));
}
}
}
/// <summary>
/// Carga los datos de contexto
/// </summary>
private RestController LoadContext(MLNode objMLNode)
{
RestController objContext = new RestController("Agent");
// Carga los datos
objContext.UserAgent = objMLNode.Nodes[cnstStrTagContextUserAgent].Value;
objContext.TimeOut = objMLNode.Nodes[cnstStrTagContextTimeOut].GetValue(20000);
objContext.Proxy.Enabled = objMLNode.Nodes[cnstStrTagContextProxyEnabled].Value.GetBool();
objContext.Proxy.Address = objMLNode.Nodes[cnstStrTagContextProxyAddress].Value;
objContext.Proxy.Port = objMLNode.Nodes[cnstStrTagContextProxyPort].Value.GetInt(0);
objContext.Proxy.User = objMLNode.Nodes[cnstStrTagContextProxyUser].Value;
objContext.Proxy.Password = objMLNode.Nodes[cnstStrTagContextProxyPassword].Value;
objContext.Proxy.MustBypassLocal = objMLNode.Nodes[cnstStrTagContextProxyByPassLocal].GetValue(false);
// Devuelve los datos de contexto
return(objContext);
}
static bool Prefix(KingdomTask __instance, bool raiseEvent)
{
try
{
if (!Main.enabled)
{
return(true);
}
if (!Main.settings.currencyFallback)
{
return(true);
}
IsStartedSetter(__instance, true);
StartedOnSetter(__instance, KingdomState.Instance.CurrentDay);
KingdomCurrencyFallback.SpendPoints(__instance.OneTimeBPCost);
if (raiseEvent)
{
OnTaskChanged(__instance);
}
EventBus.RaiseEvent((IKingdomTaskEventsHandler h) => h.OnTaskStarted(__instance));
if (__instance.SkipPlayerTime <= 0)
{
return(false);
}
Kingmaker.Game.Instance.AdvanceGameTime(TimeSpan.FromDays(__instance.SkipPlayerTime));
foreach (UnitEntityData unitEntityData in Kingmaker.Game.Instance.Player.AllCharacters)
{
RestController.ApplyRest(unitEntityData.Descriptor);
}
new KingdomTimelineManager().UpdateTimeline();
return(false);
}
catch (Exception ex)
{
Main.Error(ex);
return(true);
}
}
public void GetKnownRoute_ReturnsNullIfKnownRoutesIsNull()
{
var controller = new RestController(loggerMock.Object, anonymousServiceClientMock.Object, authenticatedServiceClientMock.Object, cacheMock.Object);
var service = new ServiceDTO
{
Code = "dummy",
Name = "dummy",
Id = Guid.NewGuid(),
Address = new Uri("http://address.to"),
UnkownRoutesPassthrough = true
};
var result = controller.GetKnownRoute(service, "path", null);
Assert.Null(result);
}
/// <summary>
/// Creates a new item using JSON model
/// </summary>
/// <param name="jsonModel">JSON formatted model</param>
/// <param name="appId">App ID (see app package)</param>
/// <param name="apiKey">API Key (see app package)</param>
/// <param name="tenantCode">Tenant code (optional)</param>
/// <returns>(<see cref="ValueTuple{Item, String}"/>) New item object or
/// error message (if available)</returns>
public static (Item, string) CreateNewItemFromJson(
string jsonModel, string appId, string apiKey, string tenantCode = null)
{
var response = RestController.HttpRequestJsonByAppId(
UriCxm.Items, Method.POST, jsonModel, appId, apiKey, tenantCode);
try
{
var item = JsonConvert.DeserializeObject <Item>(response.Content);
SetTitle(item);
return(item, null);
}
catch
{
return(null, response?.Content);
}
}
private async Task GetMeasureDataAsync()
{
if (isLoaded)
{
return;
}
string pesel = UserController.getUserPesel();
string uriRequest = ComunicationControllers.WcfConfig.getPatientMeasure(pesel);
RestController <LifeFuncMeasure> controller = new RestController <LifeFuncMeasure>();
List <LifeFuncMeasure> list = await controller.getObjects(uriRequest);
foreach (var it in list)
{
Measures.Add(it);
}
isLoaded = true;
}
/// <summary>
/// The method does not really delete user. It changes user email to a random one and sets
/// this user Status to Disabled. This gives the opportunity to create the same user.
/// Endpoint Users/Save.
/// </summary>
/// <param name="user">User dictionary with keys "Email" and "Password"</param>
public static void DeleteUser(User user)
{
SidsTenants.GetSidUd();
var userProperties = GetUserData(user);
if (userProperties == null)
{
throw new Exception($"User Directory API: user {user.Email} not found");
}
userProperties.Email = $"Auto{ActionManager.RandomNumber}@autotest.com";
userProperties.Status.Key = (int)UserStatus.Disabled;
RestController.HttpRequestJsonUserDirectory(UriUserDirectory.UserSave,
Method.POST,
Headers,
userProperties);
}
public void CombinePaths_ReturnsCorrectPath()
{
var controller = new RestController(_loggerMock.Object, _anonymousServiceClientMock.Object, _authenticatedServiceClientMock.Object, _cacheMock.Object);
var type = typeof(BaseActionApiController);
var method = type
.GetMethods(BindingFlags.NonPublic | BindingFlags.Instance)
.First(x => x.Name == "CombinePaths" && x.IsPrivate);
var result = (string)method.Invoke(controller, new object[] { "post", "comments" });
Assert.Equal("post/comments", result);
result = (string)method.Invoke(controller, new object[] { "http://address/posts/", "/comments" });
Assert.Equal("http://address/posts/comments", result);
}
public void GetSoapActionHeader_ReturnsEmptyStringWhenNoSoapActionHeaderPresent()
{
var controller = new RestController(_loggerMock.Object, _anonymousServiceClientMock.Object, _authenticatedServiceClientMock.Object, _cacheMock.Object);
IHeaderDictionary headers = new HeaderDictionary(new Dictionary <string, StringValues> {
{ "Content-Type", "application/json" }
});
var type = typeof(BaseActionApiController);
var method = type
.GetMethods(BindingFlags.NonPublic | BindingFlags.Instance)
.First(x => x.Name == "GetSoapActionHeader" && x.IsPrivate);
var result = (string)method.Invoke(controller, new object[] { headers });
Assert.True(string.IsNullOrWhiteSpace(result.ToString()));
}
public override void SetClient(RestController client)
{
base.SetClient(client);
if (this.Entries != null)
{
foreach (Entry <T> entry in this.Entries)
{
if (entry is Executable)
{
(entry as Executable).SetClient(client);
}
if (entry.Content is Executable)
{
(entry.Content as Executable).SetClient(client);
}
}
}
}
/// <summary>
/// Occurs before the action method is invoked.
/// </summary>
/// <param name="actionContext">The action context.</param>
public override void OnActionExecuting( HttpActionContext actionContext )
{
string controllerClassName = actionContext.ActionDescriptor.ControllerDescriptor.ControllerType.FullName;
string actionMethod = actionContext.Request.Method.Method;
string actionPath = actionContext.Request.GetRouteData().Route.RouteTemplate;
ISecured item = Rock.Web.Cache.RestActionCache.Read( actionMethod + actionPath );
if ( item == null )
{
item = Rock.Web.Cache.RestControllerCache.Read( controllerClassName );
if ( item == null )
{
item = new RestController();
}
}
Person person = null;
if ( actionContext.Request.Properties.Keys.Contains( "Person" ) )
{
person = actionContext.Request.Properties["Person"] as Person;
}
else
{
var principal = actionContext.Request.GetUserPrincipal();
if ( principal != null && principal.Identity != null )
{
var userLoginService = new Rock.Model.UserLoginService( new RockContext() );
var userLogin = userLoginService.GetByUserName( principal.Identity.Name );
if ( userLogin != null )
{
person = userLogin.Person;
actionContext.Request.Properties.Add( "Person", person );
}
}
}
string action = actionMethod.Equals( "GET", StringComparison.OrdinalIgnoreCase ) ?
Rock.Security.Authorization.VIEW : Rock.Security.Authorization.EDIT;
if ( !item.IsAuthorized( action, person ) )
{
actionContext.Response = new HttpResponseMessage( HttpStatusCode.Unauthorized );
}
}
public string doExecuteApiWithHeaders(string endPointUrl, string httpVerb,
string contentTypeHeader = "", string acceptHeader = "", string authHeader = "",
string jsonPostPayload = "")
{
string jsonResponse = null;
try
{
switch (httpVerb)
{
case "GET":
restClient = new RestController(
endPointUrl, HttpVerb.GET, contentTypeHeader,
acceptHeader, authHeader, jsonPostPayload);
break;
case "POST":
restClient = new RestController(
endPointUrl, HttpVerb.POST, contentTypeHeader,
acceptHeader, authHeader, jsonPostPayload);
break;
case "PUT":
restClient = new RestController(
endPointUrl, HttpVerb.PUT, contentTypeHeader,
acceptHeader, authHeader, jsonPostPayload);
break;
case "DELETE":
restClient = new RestController(
endPointUrl, HttpVerb.DELETE, contentTypeHeader,
acceptHeader, authHeader, jsonPostPayload);
break;
}
jsonResponse = restClient.MakeRequest();
}
catch (Exception e)
{
jsonResponse = e.Message;
}
return(jsonResponse);
}
public void C_Delete()
{
RestController api = new RestController(GetConnectionString());
ApplicationResultRecords result1 = api.Get();
ApplicationResultBase result2 = api.Delete(result1.Records[0].ID);
Assert.IsTrue(result2.Success);
ApplicationResultBase result3 = api.Delete(result1.Records[1].ID);
Assert.IsTrue(result3.Success);
ApplicationResultRecords result4 = api.Get();
Assert.IsTrue(result4.Success);
Assert.IsNull(result4.Records);
}
public void GetSoapActionHeader_ReturnsSanitizedValueFromProperSoapActionHeader()
{
var controller = new RestController(_loggerMock.Object, _anonymousServiceClientMock.Object, _authenticatedServiceClientMock.Object, _cacheMock.Object);
IHeaderDictionary headers = new HeaderDictionary(new Dictionary <string, StringValues> {
{ "Content-Type", "application/json" },
{ "SOAPAction", "http://tempuri.org/Calculate" }
});
var type = typeof(BaseActionApiController);
var method = type
.GetMethods(BindingFlags.NonPublic | BindingFlags.Instance)
.First(x => x.Name == "GetSoapActionHeader" && x.IsPrivate);
var result = (string)method.Invoke(controller, new object[] { headers });
Assert.Equal("Calculate", result.ToString());
}
public void mod_OnClose()
{
if (!KingmakerPatchSettings.KingdomEvents.InstantComplete)
{
this.source_OnClose();
return;
}
KingdomEventUIView previousView = this.alias_m_KingdomEventView;
// deselects the view
EventBus.RaiseEvent((IEventSceneHandler h) => h.OnEventSelected(null, this.alias_m_Cart));
if (previousView == null)
{
return;
}
if (previousView.IsFinished || previousView.AssignedLeader == null || previousView.Blueprint.NeedToVisitTheThroneRoom)
{
return;
}
bool inProgress = previousView.IsInProgress;
BlueprintUnit leader = previousView.AssignedLeader;
if (!inProgress || leader == null)
{
return;
}
previousView.Event.Resolve(previousView.Task);
if (previousView.RulerTimeRequired <= 0)
{
return;
}
foreach (UnitEntityData unitEntityData in Kingmaker.Game.Instance.Player.AllCharacters)
{
RestController.ApplyRest(unitEntityData.Descriptor);
}
}
/// <summary>
/// Envía los mensajes del proyecto
/// </summary>
private void Send(Projects.RestProgram objProgram)
{
RestController objRestController = new RestController();
// Asigna los datos de solicitud
objRestController.UserAgent = objProgram.Context.UserAgent;
objRestController.TimeOut = objProgram.Context.TimeOut;
objRestController.Certificate = objProgram.Context.Certificate;
objRestController.Proxy = objProgram.Context.Proxy;
objRestController.Authenticator = objProgram.Context.Authenticator;
// Ejecuta las instrucciones
foreach (Projects.RestInstruction objInstruction in objProgram.Instructions)
{
try
{ objInstruction.Response = objRestController.Send(objInstruction.Request); }
catch (Exception objException)
{ objInstruction.Exception = objException; }
}
}
/// <summary>
/// Deletes all places (or all of specified type) and their children within all tenants or
/// specified one
/// </summary>
/// <param name="type">Place type (optional)</param>
/// <param name="tenantTitle">Tenant title where places should be deleted (optional)</param>
public static void DeletePlaces(PlaceType type = PlaceType.Any,
TenantTitle tenantTitle = TenantTitle.All)
{
var tenantList = tenantTitle == TenantTitle.All ?
ActionManager.Tenants.ToArray() :
ActionManager.Tenants
.Where(x => x.Title == tenantTitle.ToString())
.ToArray();
foreach (var tenant in tenantList)
{
var response = RestController.HttpRequestJson(
UriCxm.Places, Method.GET, tenantCode: tenant.Code, user: TestConfig.AdminUser);
var places = JsonConvert.DeserializeObject <List <Place> >(response.Content)
.AsParallel()
.Where(x => x.Status != (int)PlaceStatus.Deleted && x.ParentId == null)
.ToArray();
foreach (var place in places)
{
place.PlaceModules = new List <PlaceModule>();
if (type == PlaceType.Any)
{
RestController.HttpRequestJson(
string.Format(UriCxm.PlacesDelete, place.Id, "true"),
Method.DELETE,
tenantCode: tenant.Code,
user: TestConfig.AdminUser);
}
else
{
if (place.DeviceTypeId == (type != 0 ? (int?)type : null))
{
RestController.HttpRequestJson(
string.Format(UriCxm.PlacesDelete, place.Id, "true"),
Method.DELETE,
tenantCode: tenant.Code,
user: TestConfig.AdminUser);
}
}
}
}
}
/// <summary>
/// Request approval of uploaded entity (item or app)
/// </summary>
/// <typeparam name="T">Entity type</typeparam>
/// <param name="entity">Entity object that should be approved (see <see cref="IApprovalEntity"/>)</param>
/// <param name="tenants">Tenant(s) where the entity is located</param>
public static T RequestApproval <T>(T entity, params TenantTitle[] tenants) where T : class, IApprovalEntity
{
var temp = GetIdAndType(entity);
var tenantIds = Array.ConvertAll(tenants, value => (int)value);
var body = new ApprovalRequest
{
EntityId = temp.EntityId,
Tenants = tenantIds,
Comments = string.Empty,
EntityType = temp.EntityType
};
RestController.HttpRequestJson(UriCxm.ApproveRequest, Method.POST, body, user: TestConfig.AdminUser);
return((T)Convert.ChangeType(
body.EntityType == (int)ApprovalEntities.Item
? ItemApi.GetById(body.EntityId)
: (object)AppApi.GetById((long)body.EntityId),
typeof(T)));
}
/// <summary>
/// Gets user SID for User Directory web services
/// </summary>
private static void GetSidUserDirectory()
{
var formattedTime = DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ss.fffZ");
var parameters = new Dictionary <string, string>
{
{ "Email", TestConfig.AdminUser.Email },
{ "DateTime", formattedTime },
{ "Password", RestController.GetSessionHash(formattedTime, TestConfig.AdminUser.Password) },
{ "lang", "en_US" }
};
var request = new RestRequest(TestConfig.UserDirectoryBaseUrlApi + UriUserDirectory.AccountLogin,
Method.POST);
request.AddHeader("appname", UdApplicationName);
request.Timeout = TestConfig.ApiRequestTimeout;
foreach (var parameter in parameters)
{
request.AddParameter(parameter.Key, parameter.Value);
}
var client = new RestClient(TestConfig.UserDirectoryBaseUrlApi);
var response = client.Execute(request);
// when no response from service, try one more time
if (response.StatusCode == 0)
{
response = client.Execute(request);
}
if (response.StatusCode == 0 || (int)response.StatusCode >= (int)HttpStatusCode.BadRequest)
{
throw new WebException(
$"User Directory: HTTP {(int) response.StatusCode} {response.StatusCode} error\n" +
$@"in request {response.Request.Method} {TestConfig.UserDirectoryBaseUrlApi}{UriUserDirectory.AccountLogin}" +
$"\nERROR:\n{response.Content}");
}
var responseJson = JsonConvert.DeserializeObject <Login>(response.Content);
UserDirectoryApi.Headers["sid"] = TestConfig.AdminUser.SidUd = responseJson.Sid;
}
private void DoRefill()
{
if (txtTimecode.Text.Length != 7)
{
MessageBox.Show(null, "Mohon masukkan 7 digit timekode", "Maaf");
return;
}
string code = Utils.Md5(txtTimecode.Text);
RestController<MessageData> rcd;
rcd = new RestController<MessageData>(Settings.RestController.ServerBase,
"ClientRefill", Settings.RestController.ResourcePrefix);
// = null;
//SessionInformation si = null;
string parameter = "?data=" + code+"&src="+_launcher.GetSessionInfo().Code;
try
{
MessageData md = rcd.GetData(parameter);
if (md != null)
{
if (md.Text != "Ok")
{
MessageBox.Show(null, "Kode sudah tidak berlaku", "Maaf,");
}
else
{
MessageBox.Show(null, "Refill berhasil", "Selamat");
}
}
txtTimecode.Text = "";
Hide();
}
catch (Exception exp)
{
MessageBox.Show(null, "Kode tidak berlaku", "Maaf,");
}
}
private void LoadClientList()
{
RestController<ClientInformations> rclist;
rclist = new RestController<ClientInformations>( Settings.RestController.ServerBase,
"stations",Settings.RestController.ResourcePrefix);
ClientInformations clist = null;
try
{
//string param = "?data=" + txtChat.Text;
clist = rclist.GetData();
if(clist != null )
{
//for
}
}
catch(Exception exp){
AddToList(txtChat.Text + " : " +exp.Message);
}
}
private void txtChat_KeyDown(object sender, KeyEventArgs e)
{
if (e.KeyCode == Keys.Return)
{
RestController<MessageData> rcd;
rcd = new RestController<MessageData>(Settings.RestController.ServerBase,
"Chat",Settings.RestController.ResourcePrefix);
MessageData md = null;
try
{
string param = "?data=" + txtChat.Text;
md = rcd.GetData(param);
if(md != null )
{
AddToList("@Nyong " + txtChat.Text);
}
}
catch(Exception exp){
AddToList(txtChat.Text + " : " +exp.Message);
}
txtChat.Text = "";
}
}
/// <summary>
/// Occurs before the action method is invoked.
/// </summary>
/// <param name="actionContext">The action context.</param>
public override void OnActionExecuting( HttpActionContext actionContext )
{
var controller = actionContext.ActionDescriptor.ControllerDescriptor;
string controllerClassName = controller.ControllerType.FullName;
string actionMethod = actionContext.Request.Method.Method;
string actionPath = actionContext.Request.GetRouteData().Route.RouteTemplate.Replace( "{controller}", controller.ControllerName );
//// find any additional arguments that aren't part of the RouteTemplate that qualified the action method
//// for example: ~/person/search?name={name}&includeHtml={includeHtml}&includeDetails={includeDetails}&includeBusinesses={includeBusinesses}
//// is a different action method than ~/person/search?name={name}
var routeQueryParams = actionContext.ActionArguments.Where(a => !actionPath.Contains("{" + a.Key + "}"));
if ( routeQueryParams.Any())
{
var actionPathQueryString = routeQueryParams.Select( a => string.Format( "{0}={{{0}}}", a.Key ) ).ToList().AsDelimited( "&" );
actionPath += "?" + actionPathQueryString;
}
ISecured item = Rock.Web.Cache.RestActionCache.Read( actionMethod + actionPath );
if ( item == null )
{
item = Rock.Web.Cache.RestControllerCache.Read( controllerClassName );
if ( item == null )
{
item = new RestController();
}
}
Person person = null;
if ( actionContext.Request.Properties.Keys.Contains( "Person" ) )
{
person = actionContext.Request.Properties["Person"] as Person;
}
else
{
var principal = actionContext.Request.GetUserPrincipal();
if ( principal != null && principal.Identity != null )
{
using ( var rockContext = new RockContext() )
{
string userName = principal.Identity.Name;
UserLogin userLogin = null;
if ( userName.StartsWith( "rckipid=" ) )
{
Rock.Model.PersonService personService = new Model.PersonService( rockContext );
Rock.Model.Person impersonatedPerson = personService.GetByEncryptedKey( userName.Substring( 8 ) );
if ( impersonatedPerson != null )
{
userLogin = impersonatedPerson.GetImpersonatedUser();
}
}
else
{
var userLoginService = new Rock.Model.UserLoginService( rockContext );
userLogin = userLoginService.GetByUserName( userName );
}
if ( userLogin != null )
{
person = userLogin.Person;
actionContext.Request.Properties.Add( "Person", person );
}
}
}
}
string action = actionMethod.Equals( "GET", StringComparison.OrdinalIgnoreCase ) ?
Rock.Security.Authorization.VIEW : Rock.Security.Authorization.EDIT;
if ( !item.IsAuthorized( action, person ) )
{
actionContext.Response = new HttpResponseMessage( HttpStatusCode.Unauthorized );
}
}
private void DoLogout()
{
RestController<MessageData> rmd;
MessageData md = null;
string resource = "ClientLogout";
string parameter = "?data="+_sessionInformation.Code;
rmd = new RestController<MessageData>(Settings.RestController.ServerBase, resource, Settings.RestController.ResourcePrefix);
try
{
md = rmd.GetData(parameter);
}
catch (Exception exp)
{
DisplayBallonTips( exp.Message ,2000);
}
_sessionInformation = null;
_pushData = null;
timerPush.Enabled = false;
_frmConfirm.Hide();
ProcessMonitor.KillAll();
Show();
FullScreen();
}
/// <summary>
/// Envía una solicitud Web utilizando oAuth
/// </summary>
private ResponseMessage GetResponseOAuth(RequestMessage objRequest)
{
RestController objRestController = new RestController("BauRest", 20000, this);
// Devuelve la respuesta del servidor
return objRestController.Send(objRequest);
}
private void timerChat_Tick(object sender, EventArgs e)
{
RestController<ChatDatas> rcd;
rcd = new RestController<ChatDatas>(Settings.RestController.ServerBase, "Chats", Settings.RestController.ResourcePrefix);
ChatDatas chatDatas = new ChatDatas();
try
{
chatDatas = rcd.GetData();
}
catch(Exception exp) {
//DisplayBallonTips(exp.Message, 1000);
}
if (chatDatas.Count > 0)
{
foreach (ChatData chatData in chatDatas)
{
_frmChat.AddToList(" @SiGanteng " + chatData.Message);
if (!_frmChat.Visible)
{
//_frmChat.BringToFront();
try
{
DisplayChat();
}
catch (Exception exp){
//DisplayBallonTips(exp.Message, 1000);
}
}
}
}
}
private void timerPush_Tick(object sender, EventArgs e)
{
_pushData = null;
if( _rpd == null )
{
string resource = "TimecodePush";
_rpd = new RestController<PushData>( Settings.RestController.ServerBase, resource, Settings.RestController.ResourcePrefix );
}
if( _sessionInformation != null && _rpd != null )
{
string parameter = "?data=" + _sessionInformation.Code;
try
{
_pushData = _rpd.GetData( parameter );
}
catch(Exception exp)
{
DisplayBallonTips( exp.Message, 2000 );
}
if ( _pushData != null && _pushData.Duration != 0)
{
string DurationText = Utils.DurationToText(_pushData.Duration);
DisplayBallonTips(DurationText, 3000);
}
//else if (_pushData.Duration <= 3)
//{
// //Logout
// DoLogout();
//}
}
if ( _pushData == null )
{
//Logout
DoLogout();
}
}
private void ExecuteCommand()
{
// Set Flag
_commandExecuteInProgress = true;
// Temporary sould replaced by config
/*RestClient restClient = new RestClient();
*/
string serverBase = Settings.RestController.ServerBase;//"http://10.0.0.13/damarnet/api/";
string resource = "", resourceSuffix = Settings.RestController.ResourcePrefix;
if (_frmMode == FormMode.QueryServerInformation)
{
resource = "ServerInformation";
ServerInformation srvInfo = null;
RestController<ServerInformation> rsi;
rsi = new RestController<ServerInformation>(serverBase, resource, resourceSuffix);
try
{
srvInfo = rsi.GetData();
_launcher.SetServerInfo(srvInfo);
_commandExecuteInProgress = false;
Hide();
}
catch (Exception exp)
{
DialogResult result;
result = MessageBox.Show(exp.Message, "Error", MessageBoxButtons.RetryCancel);
//if (result == DialogResult.Retry)
//{
_commandExecuteInProgress = false;
_commandRetry++;
//}
}
}
else if (_frmMode == FormMode.QueryClientInformation)
{
resource = "ClientInformation";
ClientInformation clientInfo = null;
RestController<ClientInformation> rsc;
rsc = new RestController<ClientInformation>(serverBase, resource, resourceSuffix);
try
{
clientInfo = rsc.GetData();
_launcher.SetClientInfo(clientInfo);
_commandExecuteInProgress = false;
Hide();
}
catch (Exception exp)
{
DialogResult result;
result = MessageBox.Show(exp.Message, "Error", MessageBoxButtons.RetryCancel);
//if (result == DialogResult.Retry)
//{
_commandExecuteInProgress = false;
_commandRetry++;
//}
}
}
else if (_frmMode == FormMode.QuerySessionInformation)
{
resource = "SessionInformation";
SessionInformation sessionInfo = null;
RestController<SessionInformation> rss;
rss = new RestController<SessionInformation>(serverBase, resource, resourceSuffix);
try
{
sessionInfo = rss.GetData();
_launcher.SetSessionInfo(sessionInfo);
_commandExecuteInProgress = false;
Hide();
}
catch (Exception exp)
{
//DialogResult result;
Hide();
//string resource = "ClientLogin"
//RestController<SessionInformation> rss;
//rss = RestController<SessionInformation>(serverBase, resource, resourceSuffix);
_launcher.BringToFront();
_frmLogin = new FormLogin(this, rss);
_frmLogin.SetMode(FormLogin.FormMode.Timecode);
_frmLogin.ShowDialog();
sessionInfo = _frmLogin.GetSessionInfo();
_launcher.SetSessionInfo(sessionInfo);
//Show();
//result = MessageBox.Show(exp.Message, "Error", MessageBoxButtons.RetryCancel);
//if (result == DialogResult.Retry)
//{
_commandExecuteInProgress = false;
//_commandRetry++;
//}
}
}
}
public MethodInfo GetActionMethodInfo(RestController controller, string actionName)
{
return ControllerHelper.GetActions(controller.GetType()).First(m => m.Name == actionName);
}
/// <summary>
/// Registers the controllers.
/// </summary>
public static void RegisterControllers()
{
var rockContext = new RockContext();
var restControllerService = new RestControllerService( rockContext );
var existingControllers = restControllerService.Queryable( "Actions" ).ToList();
var discoveredControllers = new List<RestController>();
var config = GlobalConfiguration.Configuration;
var explorer = config.Services.GetApiExplorer();
foreach(var apiDescription in explorer.ApiDescriptions)
{
var action = apiDescription.ActionDescriptor;
var name = action.ControllerDescriptor.ControllerName;
var controller = discoveredControllers.Where( c => c.Name == name ).FirstOrDefault();
if ( controller == null )
{
controller = new RestController
{
Name = name,
ClassName = action.ControllerDescriptor.ControllerType.FullName
};
discoveredControllers.Add( controller );
}
controller.Actions.Add( new RestAction
{
ApiId = apiDescription.ID,
Method = apiDescription.HttpMethod.Method,
Path = apiDescription.RelativePath
} );
}
var actionService = new RestActionService( rockContext );
foreach(var discoveredController in discoveredControllers)
{
var controller = restControllerService.Queryable( "Actions" )
.Where( c => c.Name == discoveredController.Name ).FirstOrDefault();
if ( controller == null )
{
controller = new RestController { Name = discoveredController.Name };
restControllerService.Add( controller );
}
controller.ClassName = discoveredController.ClassName;
foreach(var discoveredAction in discoveredController.Actions)
{
var action = controller.Actions.Where( a => a.ApiId == discoveredAction.ApiId ).FirstOrDefault();
{
if ( action == null )
{
action = new RestAction { ApiId = discoveredAction.ApiId };
controller.Actions.Add( action );
}
action.Method = discoveredAction.Method;
action.Path = discoveredAction.Path;
}
}
var actions = discoveredController.Actions.Select( d => d.ApiId).ToList();
foreach( var action in controller.Actions.Where( a => !actions.Contains(a.ApiId)).ToList())
{
actionService.Delete( action );
controller.Actions.Remove(action);
}
}
var controllers = discoveredControllers.Select( d => d.Name ).ToList();
foreach ( var controller in restControllerService.Queryable().Where( c => !controllers.Contains( c.Name ) ).ToList() )
{
restControllerService.Delete( controller );
}
rockContext.SaveChanges();
}
