/// <summary>
/// Retrives a single long sized parameter value.
/// </summary>
/// <param name="pname">Name of parameter to retrive.</param>
/// <returns>result.</returns>
public static long GetInteger64v(GetParameters pname)
{
long tmp = 0;
Delegates.glGetInteger64v(pname, ref tmp);
return(tmp);
}
/// <summary>
/// Retrives a single long sized parameter value from an indexed target.
/// </summary>
/// <param name="pname">Name of parameter to retrive.</param>
/// <param name="index">Meaning of index is dependant on parameter name.</param>
/// <returns>result.</returns>
public static long GetInteger64i_v(GetParameters pname, uint index)
{
long tmp = 0;
Delegates.glGetInteger64i_v(pname, index, ref tmp);
return(tmp);
}
public void when_get_request_arrives_IWillSend_has_no_valuee_then_send_msg()
{
_getParameters = new GetParameters();
var expectedMessage = "Parameter 'IWillSend' cannot be empty.";
var output = _getParameterValidator.ShouldHaveValidationErrorFor(x => x.IwillSend, _getParameters);
var actualMessage = output.Select(x => x.ErrorMessage).ToList()[0];
Assert.AreSame(expectedMessage, actualMessage);
}
public Response <List <Parameter> > Get()
{
try {
List <Parameter> parameters = GetParameters.request();
return(new Response <List <Parameter> >(parameters));
} catch (Exception ex) {
return(new Response <List <Parameter> >(ex));
}
}
public void when_get_request_arrives_IWillSend_has_invalid_type_then_send_msg()
{
_getParameters = new GetParameters();
_getParameters.IwillSend = "wrongvalue";
var expectedMessage = "Parameter 'IWillSend' value has invalid argument.";
var output = _getParameterValidator.ShouldHaveValidationErrorFor(x => x.IwillSend, _getParameters);
var actualMessage = output.Select(x => x.ErrorMessage).ToList()[0];
Assert.AreSame(expectedMessage, actualMessage);
}
public void when_get_request_arrives_ReturnMe_parameter_is_empty_then_msg_should_be_sent()
{
_getParameters = new GetParameters();
_getParameters.ReturnMe = null;
var output = _getParameterValidator.ShouldHaveValidationErrorFor(x => x.ReturnMe, _getParameters);
var expectedMessage = "ReturnMe cannot be empty.";
var actualMessage = output.Select(x => x.ErrorMessage).ToList()[0];
Assert.AreSame(expectedMessage, actualMessage);
}
when_get_request_arrives_IWillSend_has_NAME_AND_ADDRESS_and_has_valid_parameters_provided_then_no_msg_should_be_sent
()
{
_getParameters = new GetParameters();
_getParameters.IwillSend = "NameAndAddress";
_getParameters.NameAndAddress = new NameAndAddress {
Surname = "Doe", FirstName = "John"
};
_getParameterValidator.ShouldNotHaveValidationErrorFor(x => x.NameAndAddress, _getParameters);
}
when_get_request_arrives_IWillSend_has_NAME_AND_ADDRESS_and_not_parameters_provided_then_msg_should_be_sent()
{
_getParameters = new GetParameters();
_getParameters.IwillSend = "NameAndAddress";
_getParameters.NameAndAddress = null;
var output = _getParameterValidator.ShouldHaveValidationErrorFor(x => x.NameAndAddress, _getParameters);
var expectedMessage = "NameAndAddress cannot be empty.";
var actualMessage = output.Select(x => x.ErrorMessage).ToList()[0];
Assert.AreSame(expectedMessage, actualMessage);
}
when_get_request_arrives_IWillSend_has_KeyValuePair_and_no_parameters_provided_then_msg_should_be_sent()
{
_getParameters = new GetParameters();
_getParameters.IwillSend = "KeyValuePair";
_getParameters.KeyValue = null;
var output = _getParameterValidator.ShouldHaveValidationErrorFor(x => x.KeyValue, _getParameters);
var expectedMessage = "KeyValue cannot be empty.";
var actualMessage = output.Select(x => x.ErrorMessage).ToList()[0];
Assert.AreSame(expectedMessage, actualMessage);
}
public bool BindModel(HttpActionContext actionContext, ModelBindingContext bindingContext)
{
try
{
GetParameters parameters = new GetParameters();
parameters.RequestIdentification =
bindingContext.GetValue("RequestIdentification").ToType <string>();
parameters.IwillSend = bindingContext.GetValue("Iwillsend").ToType <string>();
parameters.KeyValue.Key = bindingContext.GetValue("KeyValue.Key").ToType <string>();
parameters.KeyValue.Value = bindingContext.GetValue("KeyValue.Value").ToType <string>();
parameters.NameAndAddress.Title = bindingContext.GetValue("NameAndAdress.Title").ToType <string>();
parameters.NameAndAddress.Surname = bindingContext.GetValue("NameAndAddress.Surname").ToType <string>();
parameters.NameAndAddress.FirstName = bindingContext.GetValue("NameAndAddress.Firstname").ToType <string>();
parameters.NameAndAddress.Dob = bindingContext.GetValue("NameAndAddress.Dob").ToType <DateTime>();
parameters.NameAndAddress.Email = bindingContext.GetValue("NameAndAddress.Email").ToType <string>();
parameters.NameAndAddress.Phone = bindingContext.GetValue("NameAndAddress.Phone").ToType <string>();
parameters.NameAndAddress.Address.Address1 = bindingContext.GetValue("NameAndAddress.Address.Address1").ToType <string>();
parameters.NameAndAddress.Address.Address2 = bindingContext.GetValue("NameAndAddress.Address.Address2").ToType <string>();
parameters.NameAndAddress.Address.Address3 = bindingContext.GetValue("NameAndAddress.Address.Address3").ToType <string>();
parameters.NameAndAddress.Address.Address4 = bindingContext.GetValue("NameAndAddress.Address.Address4").ToType <string>();
parameters.NameAndAddress.Address.Postcode = bindingContext.GetValue("NameAndAddress.Address.Postcode").ToType <string>();
parameters.ReturnMe.MailingHistory.Product = bindingContext.GetValue("Returnme.MailingHistory.Product").ToType <string>();
parameters.ReturnMe.MailingHistory.FromDate = bindingContext.GetValue("ReturnMe.MailingHistory.FromDate").ToType <DateTime>();
parameters.ReturnMe.MailingHistory.ToDate = bindingContext.GetValue("ReturnMe.MailingHistory.ToDate").ToType <DateTime>();
parameters.ReturnMe.MailingHistory.FieldsTobeReturned = bindingContext.GetValue("ReturnMe.MailingHistory.FieldsTobeReturned").ToType <List <string> >();
parameters.ReturnMe.CustomerKeys = bindingContext.GetValue("ReturnMe.CustomerKeys").ToType <List <string> >();
parameters.Version = bindingContext.GetValue("Version").ToType <string>();
if (string.IsNullOrEmpty(parameters.Version) || parameters.Version.ToLower() != "v1")
{
bindingContext.ModelState.AddModelError("Version", "There is no version information found or has invalid version number in the URL");
}
// parameters.GroupCodes = parameters.ReturnMe.CustomerKeys.ToGroupCodeEnum();
//Note, following logic to extract actual returnme items from the get parameter collection so that processing can be easier in later stage.
// if you add new ReturnMe item that value should be added to where clause x.Contains("NewRequestMe")
var returnMeItems = actionContext.Request.GetQueryNameValuePairs().Where(x => x.Key.ToLower().Contains("returnme")).SelectMany(s => s.Key.Split('.')).ToList();
var distinctreturnMeItems = returnMeItems.Distinct().Where(x =>
x.ToLower().Contains("mailinghistory") || x.ToLower().Contains("customerkeys") ||
x.ToLower().Contains("permissions") || x.ToLower().Contains("membership"))
.ToList();
parameters.ResponseRequestedItems = distinctreturnMeItems;
parameters.ProcessStrategy = bindingContext.GetValue("Iwillsend").ToType <string>();
bindingContext.Model = parameters;
}
catch (Exception ex)
{
log.Error("GetParameterModelBinder: " + ex.Message, ex);
}
return(true);
}
internal PlaceholderMethodSymbol(
NamedTypeSymbol container,
string name,
GetTypeParameters getTypeParameters,
GetReturnType getReturnType,
GetParameters getParameters)
{
_container = container;
_name = name;
_typeParameters = getTypeParameters(this);
_returnType = getReturnType(this);
_parameters = getParameters(this);
}
internal PlaceholderMethodSymbol(
NamedTypeSymbol container,
string name,
GetTypeParameters getTypeParameters,
GetReturnType getReturnType,
GetParameters getParameters)
{
_container = container;
_name = name;
_typeParameters = getTypeParameters(this);
_returnType = getReturnType(this);
_parameters = getParameters(this);
}
internal PlaceholderMethodSymbol(
NamedTypeSymbol container,
CSharpSyntaxNode syntax,
string name,
GetTypeParameters getTypeParameters,
GetReturnType getReturnType,
GetParameters getParameters,
bool returnValueIsByRef) :
this(container, syntax, name)
{
_typeParameters = getTypeParameters(this);
_returnType = getReturnType(this);
_parameters = getParameters(this);
_returnValueIsByRef = returnValueIsByRef;
}
internal PlaceholderMethodSymbol(
NamedTypeSymbol container,
CSharpSyntaxNode syntax,
string name,
GetTypeParameters getTypeParameters,
GetReturnType getReturnType,
GetParameters getParameters,
bool returnValueIsByRef) :
this(container, syntax, name)
{
_typeParameters = getTypeParameters(this);
_returnType = getReturnType(this);
_parameters = getParameters(this);
_returnValueIsByRef = returnValueIsByRef;
}
public void when_Get_request_arrives_and_no_customerskey_provided_in_customerKeys_ReturnMe_message_should_be_sent()
{
var getParameters = new GetParameters();
getParameters.IwillSend = "KeyValuePair";
getParameters.ReturnMe = new ReturnMe();
getParameters.ReturnMe.CustomerKeys = new System.Collections.Generic.List <string>();
var expectedMessage = "Customer keys cannot be null or empty.";
var context = new ValidationContext(getParameters, new PropertyChain(), ValidatorOptions.ValidatorSelectors.DefaultValidatorSelectorFactory());
var propertyValidatorContext = new PropertyValidatorContext(context, PropertyRule.Create <GetParameters, ReturnMe>(t => t.ReturnMe), "ReturnMe");
var validator = new ReturnMeValidator.CustomerKeysCannotBeEmpty();
var output = validator.Validate(propertyValidatorContext);
var actualMessage = output.Select(x => x.ErrorMessage).ToList().Count > 0 ? output.Select(x => x.ErrorMessage).ToList()[0] : "";
Assert.AreEqual(expectedMessage, actualMessage);
}
internal PlaceholderMethodSymbol(
NamedTypeSymbol container,
CSharpSyntaxNode syntax,
string name,
TypeSymbol returnType,
GetParameters getParameters) :
this(container, syntax, name)
{
Debug.Assert(
(returnType.SpecialType == SpecialType.System_Void) ||
(returnType.SpecialType == SpecialType.System_Object) ||
(returnType.Name == "Exception"));
_typeParameters = ImmutableArray <TypeParameterSymbol> .Empty;
_returnType = returnType;
_parameters = getParameters(this);
}
internal PlaceholderMethodSymbol(
NamedTypeSymbol container,
CSharpSyntaxNode syntax,
string name,
TypeSymbol returnType,
GetParameters getParameters) :
this(container, syntax, name)
{
Debug.Assert(
(returnType.SpecialType == SpecialType.System_Void) ||
(returnType.SpecialType == SpecialType.System_Object) ||
(returnType.Name == "Exception"));
_typeParameters = ImmutableArray<TypeParameterSymbol>.Empty;
_returnType = returnType;
_parameters = getParameters(this);
}
public IActionResult Get(GetParameters parameters)
{
var shelves = _shelvesRepository.Get(parameters.pageNumber, parameters.pageSize, parameters.Fields, parameters.OrderBy, parameters.OrderDirection, parameters.SearchQuery);
var metadata = new
{
totalCount = shelves.TotalCount,
pageSize = shelves.PageSize,
currentPage = shelves.CurrentPage,
totalPages = shelves.Totalpages,
nextPage = shelves.HasNextPage ? GeneratePagingLink(ResourceUriPagingType.NextPage, parameters, "Shelve") : null,
previousPage = shelves.HasPreviousPage ? GeneratePagingLink(ResourceUriPagingType.PreviousPage, parameters, "Shelve") : null
};
ViewBag.MetadataObjects = metadata;
return(Ok(_mapper.Map <IEnumerable <ShelfVM> >(shelves)));
}
public GetResult Execute(GetParameters parameters)
{
return new GetResult
{
Operators = repository.Query<Operator>()
.OrderBy(o => o.Extension)
.Select(o =>
new OperatorResult
{
ID = o.ID,
Name = o.Name,
Extension = o.Extension,
CallStatus = o.CallStatus,
CallStatusText = o.CallStatus == CallStatus.Available
? "available"
: "on call"
})
.ToArray()
};
}
public string GeneratePagingLink(ResourceUriPagingType type, GetParameters parameters, string resourceType)
{
switch (type)
{
case ResourceUriPagingType.NextPage:
parameters.pageNumber += 1;
break;
case ResourceUriPagingType.PreviousPage:
parameters.pageNumber = parameters.pageNumber > 1 ? parameters.pageNumber - 1 : 0;
break;
default:
break;
}
var urlHelper = (IUrlHelper)_httpContextAccessor.HttpContext.Items[BaseController.UrlHelper];
//var resourceName = resourceType.GetType().Name;
var url = urlHelper.Link($"Get{resourceType}s", parameters);
return(url);
}
public ProcessRequestContext(GetParameters parameters,
IMailingHistoryService mailingHistoryService,
IMciRequestService mciRequestService,
IClientScopeService clientScopeService,
ILog logger, IPermissionService permissionsService,
IMembershipService membershipService)
{
_parameters = parameters;
_mailingHistoryService = mailingHistoryService;
_mciRequestService = mciRequestService;
_clientScopeService = clientScopeService;
_logger = logger;
_permissionsService = permissionsService;
_membershipService = membershipService;
Assembly assembly = Assembly.GetExecutingAssembly();
var types = assembly.GetTypes();
var processType = types.Where(x => x.GetInterface("IGetRequestProcess") != null).ToList();
var callingObj =
processType.SingleOrDefault(x => x.Name.ToLower() == $"{parameters.ProcessStrategy}Strategy".ToLower());
if (callingObj == null)
{
_logger.Error(
"NameAndAddressStrategy: " + "ErrorTag: " + ErrorTagProvider.ErrorTag + " -- " + $"'{typeof(IGetRequestProcess).Assembly.FullName.ToLower()}" +
"Strategy\' is not implemented");
throw new ArgumentException($"'{typeof(IGetRequestProcess).Assembly.FullName.ToLower()}" +
"Strategy\' is not implemented");
}
GetRequestProcess =
(IGetRequestProcess)
Activator.CreateInstance(callingObj, _parameters, _mailingHistoryService, _mciRequestService,
_clientScopeService, _logger, _permissionsService, _membershipService);
}
// Returns call log records by ID.
public Task <UserCallLogRecord> Get(GetParameters parameters)
{
return(Get(parameters as object));
}
public static void GetIntegeri_v(GetParameters pname, uint index, int[] data)
{
Delegates.glGetIntegeri_v(pname, index, ref data[0]);
}
// Checks if a certain user permission is activated for a particular extension.
public Task <AuthProfileCheckResource> Get(GetParameters parameters)
{
return(Get(parameters as object));
}
public static void GetIntegerIndexedvEXT(GetParameters value, uint index, ref int data)
{
Delegates.glGetIntegerIndexedvEXT(value, index, ref data);
}
/// <summary>
/// Retrives a possible array long sized parameters from an indexed target.
/// </summary>
/// <param name="pname">Name of parameter to retrive.</param>
/// <param name="index">Meaning of index is dependent on Paramenter Name.</param>
/// <param name="params">Preallocated long array to write result of sufficient size.</param>
public static void GetInteger64i_v(GetParameters pname, uint index, long[] @params)
{
Delegates.glGetInteger64i_v(pname, index, ref @params[0]);
}
/// <summary>
/// Retrives a single long sized parameter value.
/// </summary>
/// <param name="pname">Name of parameter to retrive.</param>
/// <returns>result.</returns>
public static long GetInteger64v(GetParameters pname)
{
long tmp = 0;
Delegates.glGetInteger64v(pname, ref tmp);
return tmp;
}
/// <summary>
/// return the value or values of a selected parameter
/// These four commands return values for simple state variables in GL. pname is a symbolic constant indicating the state variable to be returned, and params is a pointer to an array of the indicated type in which to place the returned data.
/// </summary>
/// <param name="pname">Specifies the parameter value to be returned. The symbolic constants in the enum are accepted.</param>
/// <param name="params">Returns the value or values of the specified parameter.</param>
/// <remarks>Type conversion is performed if params has a different type than the state variable value being requested. If glGetBooleanv is called, a floating-point (or integer) value is converted to GL_FALSE if and only if it is 0.0 (or 0). Otherwise, it is converted to GL_TRUE. If glGetIntegerv is called, boolean values are returned as GL_TRUE or GL_FALSE, and most floating-point values are rounded to the nearest integer value. Floating-point colors and normals, however, are returned with a linear mapping that maps 1.0 to the most positive representable integer value and -1.0 to the most negative representable integer value. If glGetFloatv or glGetDoublev is called, boolean values are returned as GL_TRUE or GL_FALSE, and integer values are converted to floating-point values.</remarks>
public static void GetDoublev(GetParameters pname, double[] @params)
{
Delegates.glGetDoublev(pname, ref @params[0]);
}
/// <summary>
/// return the value or values of a selected parameter
/// These four commands return values for simple state variables in GL. pname is a symbolic constant indicating the state variable to be returned, and params is a pointer to an array of the indicated type in which to place the returned data.
/// </summary>
/// <param name="pname">Specifies the parameter value to be returned. The symbolic constants in the enum are accepted.</param>
/// <param name="params">Returns the value or values of the specified parameter.</param>
/// <remarks>Type conversion is performed if params has a different type than the state variable value being requested. If glGetBooleanv is called, a floating-point (or integer) value is converted to GL_FALSE if and only if it is 0.0 (or 0). Otherwise, it is converted to GL_TRUE. If glGetIntegerv is called, boolean values are returned as GL_TRUE or GL_FALSE, and most floating-point values are rounded to the nearest integer value. Floating-point colors and normals, however, are returned with a linear mapping that maps 1.0 to the most positive representable integer value and -1.0 to the most negative representable integer value. If glGetFloatv or glGetDoublev is called, boolean values are returned as GL_TRUE or GL_FALSE, and integer values are converted to floating-point values.</remarks>
public static void GetFloatv(GetParameters pname, float[] @params)
{
Delegates.glGetFloatv(pname, ref @params[0]);
}
public static extern void glGetIntegerv(GetParameters pname, ref int @params);
/// <summary>
/// Gets double values from an indexed parameter targets.
/// </summary>
/// <param name="pname">Name of parameter to retrive.</param>
/// <param name="index">Meaning is dependert on pname.</param>
/// <param name="data"></param>
public static void GetDoublei_v(GetParameters pname, uint index, double[] data)
{
Delegates.glGetDoublei_v(pname, index, ref data[0]);
}
public static extern void glGetFloatv(GetParameters pname, ref float @params);
public static extern void glGetDoublev(GetParameters pname, ref double @params);
public static extern void glGetBooleanv(GetParameters pname, ref bool @params);
// Returns the information on a certain timezone.
public Task <GetTimezoneInfoResponse> Get(GetParameters parameters)
{
return(Get(parameters as object));
}
/// <summary>
/// return the value or values of a selected parameter
/// These four commands return values for simple state variables in GL. pname is a symbolic constant indicating the state variable to be returned, and params is a pointer to an array of the indicated type in which to place the returned data.
/// </summary>
/// <param name="pname">Specifies the parameter value to be returned. The symbolic constants in the enum are accepted.</param>
/// <param name="params">Returns the value or values of the specified parameter.</param>
/// <remarks>Type conversion is performed if params has a different type than the state variable value being requested. If glGetBooleanv is called, a floating-point (or integer) value is converted to GL_FALSE if and only if it is 0.0 (or 0). Otherwise, it is converted to GL_TRUE. If glGetIntegerv is called, boolean values are returned as GL_TRUE or GL_FALSE, and most floating-point values are rounded to the nearest integer value. Floating-point colors and normals, however, are returned with a linear mapping that maps 1.0 to the most positive representable integer value and -1.0 to the most negative representable integer value. If glGetFloatv or glGetDoublev is called, boolean values are returned as GL_TRUE or GL_FALSE, and integer values are converted to floating-point values.</remarks>
public static void GetIntegerv(GetParameters pname, int[] @params)
{
Delegates.glGetIntegerv(pname, ref @params[0]);
}
/// <summary>
/// Retrives a single long sized parameter value from an indexed target.
/// </summary>
/// <param name="pname">Name of parameter to retrive.</param>
/// <param name="index">Meaning of index is dependant on parameter name.</param>
/// <returns>result.</returns>
public static long GetInteger64i_v(GetParameters pname, uint index)
{
long tmp = 0;
Delegates.glGetInteger64i_v(pname, index, ref tmp);
return tmp;
}
/// <summary>
/// return the value or values of a selected parameter
/// These four commands return values for simple state variables in GL. pname is a symbolic constant indicating the state variable to be returned, and params is a pointer to an array of the indicated type in which to place the returned data.
/// </summary>
/// <param name="pname">Specifies the parameter value to be returned. The symbolic constants in the enum are accepted.</param>
/// <returns>Returns the value or values of the specified parameter.</returns>
/// <remarks>Type conversion is performed if params has a different type than the state variable value being requested. If glGetBooleanv is called, a floating-point (or integer) value is converted to GL_FALSE if and only if it is 0.0 (or 0). Otherwise, it is converted to GL_TRUE. If glGetIntegerv is called, boolean values are returned as GL_TRUE or GL_FALSE, and most floating-point values are rounded to the nearest integer value. Floating-point colors and normals, however, are returned with a linear mapping that maps 1.0 to the most positive representable integer value and -1.0 to the most negative representable integer value. If glGetFloatv or glGetDoublev is called, boolean values are returned as GL_TRUE or GL_FALSE, and integer values are converted to floating-point values.</remarks>
public static int GetIntegerv(GetParameters pname)
{
int tmp = 0;
Delegates.glGetIntegerv(pname, ref tmp);
return tmp;
}
public void when_get_request_arrives_IWillSend_has_valid_type_then_no_msg_should_be_sent()
{
_getParameters = new GetParameters();
_getParameters.IwillSend = "NameAndAddress";
_getParameterValidator.ShouldNotHaveValidationErrorFor(x => x.IwillSend, _getParameters);
}
//
public Task <UserSearchResponse> Get(GetParameters parameters)
{
return(Get(parameters as object));
}
// Returns the information on the Free Conference Calling (FCC) feature for a given extension.
public Task <GetConferencingInfoResponse> Get(GetParameters parameters)
{
return(Get(parameters as object));
}
/// <summary>
/// Gets double values from an indexed parameter targets.
/// </summary>
/// <param name="pname">Name of parameter to retrive.</param>
/// <param name="index">Meaning is dependert on pname.</param>
/// <param name="data"></param>
public static void GetDoublei_v(GetParameters pname, uint index, double[] data)
{
Delegates.glGetDoublei_v(pname, index, ref data[0]);
}
public static void GetBooleanIndexedvEXT(GetParameters value, uint index, ref bool data)
{
Delegates.glGetBooleanIndexedvEXT(value, index, ref data);
}
/// <summary>
/// Gets float values from an indexed parameter target.
/// </summary>
/// <param name="pname">Name of parameter to retrive.</param>
/// <param name="index">Meaning is dependert on pname.</param>
/// <param name="data"></param>
public static void GetFloati_v(GetParameters pname, uint index, float[] data)
{
Delegates.glGetFloati_v(pname, index, ref data[0]);
}
// Returns presence status of an extension or several extensions by their ID(s). Batch request is supported. The 'presenceStatus' is returned as Offline (the parameters 'telephonyStatus', 'message', 'userStatus' and 'dndStatus' are not returned at all) for the following extension types: Department/Announcement Only/Take Messages Only (Voicemail)/Fax User/Paging Only Group/Shared Lines Group/IVR Menu/Application Extension/Park Location.If the user requests his/her own presence status, the response contains actual presence status even if the status publication is turned off. Batch request is supported. For batch requests the number of extensions in one request is limited to 30. If more extensions are included in the request, the error code 400 Bad Request is returned with the logical error code InvalidMultipartRequest and the corresponding message 'Extension Presence Info multipart request is limited to 30 extensions'.
public Task <GetPresenceInfo> Get(GetParameters parameters)
{
return(Get(parameters as object));
}
public IWebClientRequest SetGetData(string key, string value)
{
GetParameters.Add(new KeyValuePair <string, string>(key, value));
return(this);
}
public static void GetBooleani_v(GetParameters pname, uint index, bool[] data)
{
Delegates.glGetBooleani_v(pname, index, ref data[0]);
}
public ActionResult <IEnumerable <Ficha> > Get([FromQuery] GetParameters parametros)
{
IEnumerable <Ficha> lista = business.Listar(parametros.ProfessorId, parametros.ClienteId);
return(lista.ToList());
}
// <p style='font-style:italic;'>Since 1.0.15 (Release 7.0)</p><p>Returns the extension answering rules.</p><h4>Required Permissions</h4><table class='fullwidth'><thead><tr><th>Permission</th><th>Description</th></tr></thead><tbody><tr><td class='code'>ReadAccounts</td><td>Viewing user account info (including name, business name, address and phone number/account number)</td></tr></tbody></table><h4>Usage Plan Group</h4><p>Light</p>
public Task <bool> Get(GetParameters parameters)
{
return(Get(parameters as object));
}
// <p style='font-style:italic;'>Since 1.0.31 (Release 9.2)</p><p>Returns the list of users requested.</p><h4>Required Permissions</h4><table class='fullwidth'><thead><tr><th>Permission</th><th>Description</th></tr></thead><tbody><tr><td class='code'>ReadAccounts</td><td>Viewing user account info (including name, business name, address and phone number/account number)</td></tr></tbody></table><h4>API Group</h4><p>Medium</p>
public Task <GetUserListResponse> Get(GetParameters parameters)
{
return(Get(parameters as object));
}
/// <summary>
/// return the value or values of a selected parameter
/// These four commands return values for simple state variables in GL. pname is a symbolic constant indicating the state variable to be returned, and params is a pointer to an array of the indicated type in which to place the returned data.
/// </summary>
/// <param name="pname">Specifies the parameter value to be returned. The symbolic constants in the enum are accepted.</param>
/// <param name="params">Returns the value or values of the specified parameter.</param>
/// <remarks>Type conversion is performed if params has a different type than the state variable value being requested. If glGetBooleanv is called, a floating-point (or integer) value is converted to GL_FALSE if and only if it is 0.0 (or 0). Otherwise, it is converted to GL_TRUE. If glGetIntegerv is called, boolean values are returned as GL_TRUE or GL_FALSE, and most floating-point values are rounded to the nearest integer value. Floating-point colors and normals, however, are returned with a linear mapping that maps 1.0 to the most positive representable integer value and -1.0 to the most negative representable integer value. If glGetFloatv or glGetDoublev is called, boolean values are returned as GL_TRUE or GL_FALSE, and integer values are converted to floating-point values.</remarks>
public static void GetBooleanv(GetParameters pname, bool[] @params)
{
Delegates.glGetBooleanv(pname, ref @params[0]);
}
/// <summary>
/// Gets float values from an indexed parameter target.
/// </summary>
/// <param name="pname">Name of parameter to retrive.</param>
/// <param name="index">Meaning is dependert on pname.</param>
/// <param name="data"></param>
public static void GetFloati_v(GetParameters pname, uint index, float[] data)
{
Delegates.glGetFloati_v(pname, index, ref data[0]);
}
