public Task <ActionResult> Update([FromBody] AspNetCoreWebApi.Entity.Request newObj)
{
Console.WriteLine("Dedicated implement of route {0}", this.RouteData.ToString());
String serviceName = CaseConvert.UnderscoreToCamel(newObj.GetType().Name, false);
// TODO : validar se entity.getState() é um State com antecessor e precedente validos.
return(RequestFilter.GetObject <AspNetCoreWebApi.Entity.Request>(this.User.Identity, this.Request, this.entityManager, serviceName).ContinueWith <ActionResult>(taskOldObj => {
return RequestFilter.ProcessUpdate(this.User.Identity, this.Request, this.entityManager, serviceName, newObj).ContinueWith <ActionResult>(taskResponse => {
ActionResult response = taskResponse.Result;
if (response is OkResult)
{
RequestState stateOld = RequestProductEndpoint.GetRequestState(this.entityManager, taskOldObj.Result.State);
RequestState state = RequestProductEndpoint.GetRequestState(this.entityManager, newObj.State);
List <RequestProduct> list = DbUtils.Find <RequestProduct>(this.entityManager, null, QueryMap.Create().AddNext("crudGroupOwner", newObj.CrudGroupOwner).AddNext("request", newObj.Id), null, null, null).Result;
foreach (RequestProduct requestProduct in list)
{
}
}
return response;
}).Result;
}));
}
public Task <ActionResult> Create([FromBody] AspNetCoreWebApi.Entity.Request obj)
{
Console.WriteLine("Dedicated implement of route {0}", this.RouteData.ToString());
// TODO : validar se entity.getState() é um State com antecessor vazio.
if (obj.Date == null)
{
obj.Date = System.DateTime.Now;
}
String serviceName = CaseConvert.UnderscoreToCamel(obj.GetType().Name, false);
return(RequestFilter.ProcessCreate <AspNetCoreWebApi.Entity.Request>(this.User.Identity, this.entityManager, serviceName, obj));
}
public override void Configure(System.Collections.Specialized.NameValueCollection attributes)
{
var quoteIdentifiers = attributes["QuoteIdentifiers"];
if (quoteIdentifiers != null)
QuoteIdentifiers = Common.Convert.ToBoolean(quoteIdentifiers);
var queryCaseConcert = attributes["QueryCaseConvert"];
if (queryCaseConcert != null)
{
try
{
QueryCaseConvert = (CaseConvert)Enum.Parse(typeof(CaseConvert), queryCaseConcert, true);
}
catch { }
}
base.Configure(attributes);
}
public override void Configure(System.Collections.Specialized.NameValueCollection attributes)
{
var quoteIdentifiers = attributes["QuoteIdentifiers"];
if (quoteIdentifiers != null)
{
QuoteIdentifiers = Common.Convert.ToBoolean(quoteIdentifiers);
}
var queryCaseConcert = attributes["QueryCaseConvert"];
if (queryCaseConcert != null)
{
try
{
QueryCaseConvert = (CaseConvert)Enum.Parse(typeof(CaseConvert), queryCaseConcert, true);
}
catch { }
}
base.Configure(attributes);
}
public static void UpdateCrudServices(DbContext entityManager)
{
Func <Type, String, String> generateFieldsStr = (entityClass, strFields) => {
var fields = entityClass.GetProperties();
JObject jsonOriginal = JObject.Parse(strFields);
JObject jsonBuilder = new JObject();
foreach (var field in fields)
{
String fieldName = CaseConvert.UnderscoreToCamel(field.Name, false);
ColumnAttribute column = field.GetCustomAttribute <ColumnAttribute> ();
ForeignKeyAttribute foreignKey = field.GetCustomAttribute <ForeignKeyAttribute>();
DisplayAttribute display = field.GetCustomAttribute <DisplayAttribute>();
MaxLengthAttribute maxLength = field.GetCustomAttribute <MaxLengthAttribute>();
EditableAttribute editable = field.GetCustomAttribute <EditableAttribute>();
FilterUIHintAttribute filterUIHint = field.GetCustomAttribute <FilterUIHintAttribute>();
String typeDesc = field.PropertyType.FullName;
if (typeDesc.Contains(".String"))
{
typeDesc = "s";
}
else if (typeDesc.Contains(".Int32"))
{
typeDesc = "i";
}
else if (typeDesc.Contains(".Boolean"))
{
typeDesc = "b";
}
else if (typeDesc.Contains(".Decimal"))
{
typeDesc = "n3"; // numero com separação de milhar com casas decimais
if (column != null && column.TypeName != null)
{
if (column.TypeName.Equals("numeric(9,2)"))
{
typeDesc = "n2"; // numero com separação de cents
}
else if (column.TypeName.Equals("numeric(9,1)"))
{
typeDesc = "n1"; // numero com separação de decimais
}
}
}
else if (typeDesc.Contains(".DateTime"))
{
typeDesc = "datetime-local"; // data e hora completa
}
else if (typeDesc.Contains(".Date"))
{
typeDesc = "date"; // data
}
else if (typeDesc.Contains(".Time"))
{
typeDesc = "time"; // hora completa
}
else
{
Console.WriteLine("{0} : {1} : Unknow type : {2}", entityClass.Name, field.Name, typeDesc);
continue;
}
// type (columnDefinition), readOnly, hiden, primaryKey, required (insertable), updatable, defaultValue, length, precision, scale
JObject jsonNewValue = new JObject();
if (typeDesc != null)
{
jsonNewValue.Add("type", typeDesc);
}
//if (column != null && column.updatable() == false) {
// jsonBuilderValue.Add("updatable", false);
//}
if (maxLength != null && maxLength.Length != 255)
{
jsonNewValue.Add("length", maxLength.Length);
}
//if (column != null && column.precision() != 0) {
// jsonBuilderValue.Add("precision", column.precision());
//}
//if (column != null && column.scale() != 0) {
// jsonBuilderValue.Add("scale", column.scale());
//}
if (fieldName.Equals("crudGroupOwner") && entityClass.Name.Equals("CrudGroupOwner") == false)
{
jsonNewValue.Add("hiden", true);
}
if (field.GetCustomAttribute <KeyAttribute> () != null)
{
jsonNewValue.Add("primaryKey", true);
}
if (filterUIHint != null && filterUIHint.ControlParameters.ContainsKey("defaultValue"))
{
jsonNewValue.Add("defaultValue", (String)filterUIHint.ControlParameters["defaultValue"]);
}
if (filterUIHint != null && filterUIHint.ControlParameters.ContainsKey("isClonable"))
{
jsonNewValue.Add("isClonable", (String)filterUIHint.ControlParameters["isClonable"]);
}
if (filterUIHint != null && filterUIHint.ControlParameters.ContainsKey("options"))
{
jsonNewValue.Add("options", (String)filterUIHint.ControlParameters["options"]);
}
if (field.GetCustomAttribute <RequiredAttribute>() != null || (field.GetCustomAttribute <KeyAttribute> () != null && field.GetCustomAttribute <DatabaseGeneratedAttribute> () == null))
{
jsonNewValue.Add("required", true);
}
if (foreignKey != null && foreignKey.Name != null)
{
jsonNewValue.Add("service", CaseConvert.UnderscoreToCamel(foreignKey.Name, false));
}
if (display != null && display.Name != null)
{
jsonNewValue.Add("title", display.Name);
}
if (field.GetCustomAttribute <DatabaseGeneratedAttribute>() != null)
{
jsonNewValue.Add("hiden", true);
}
if (editable != null && editable.AllowEdit == false)
{
jsonNewValue.Add("readOnly", true);
}
if (jsonOriginal.ContainsKey(fieldName))
{
JToken jsonOldValue = jsonOriginal.GetValue(fieldName);
JObject jsonValue = new JObject();
jsonValue.Merge(jsonNewValue);
jsonValue.Merge(jsonOldValue);
jsonBuilder.Add(fieldName, jsonValue);
// SHOW WARNING
{
String oldFieldStr = jsonOldValue.ToString(Formatting.Indented);
String newFieldStr = jsonNewValue.ToString(Formatting.Indented);
if (oldFieldStr.Equals(newFieldStr) == false)
{
Console.WriteLine("{0} : {1} : diference (database data / classes data) :", entityClass.Name, field.Name);
Console.WriteLine(oldFieldStr);
Console.WriteLine(newFieldStr);
}
}
}
else
{
jsonBuilder.Add(fieldName, jsonNewValue);
}
}
return(jsonBuilder.ToString(Formatting.None));
};
foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
{
foreach (Type entityClass in assembly.GetTypes())
{
if (entityClass.GetCustomAttributes(typeof(TableAttribute), true).Length > 0)
{
String serviceName = CaseConvert.UnderscoreToCamel(entityClass.Name, false);
CrudService service = entityManager.Find <CrudService> (serviceName);
if (service != null)
{
String oldFields = service.Fields;
String newFields = generateFieldsStr(entityClass, oldFields);
if (oldFields.Equals(newFields) == false)
{
service.Fields = newFields;
entityManager.Update(service);
entityManager.SaveChanges();
}
}
else
{
service = new CrudService();
service.Name = serviceName;
service.Fields = generateFieldsStr(entityClass, "{}");
entityManager.Add(service);
entityManager.SaveChanges();
}
RequestFilter.mapClass.Add(serviceName, entityClass);
RequestFilter.mapService.Add(serviceName, service);
}
}
}
}
// This method sends the same Bidding object to all opened sessions
public static void Notify(Object obj, String serviceName, Boolean isRemove)
{
JObject serviceFields = JObject.Parse(RequestFilter.mapService[serviceName].Fields);
Func <JObject> GetPrimaryKey = () => {
JObject primaryKeyBuilder = new JObject();
foreach (var field in serviceFields)
{
if (field.Value["primaryKey"] != null && field.Value.Value <Boolean> ("primaryKey") == true)
{
Object value = obj.GetType().GetProperty(CaseConvert.UnderscoreToCamel(field.Key, true)).GetValue(obj);
if (value is String)
{
primaryKeyBuilder.Add(field.Key, (String)value);
}
else if (value is int)
{
primaryKeyBuilder.Add(field.Key, (int)value);
}
else if (value is Boolean)
{
primaryKeyBuilder.Add(field.Key, (Boolean)value);
}
}
}
return(primaryKeyBuilder);
};
JObject primaryKey = GetPrimaryKey();
JObject msg = new JObject();
msg.Add("service", serviceName);
msg.Add("primaryKey", primaryKey);
if (isRemove == false)
{
msg.Add("action", "notify");
}
else
{
msg.Add("action", "delete");
}
String str = msg.ToString(Formatting.Indented);
int? objCrudGroupOwner = primaryKey.ContainsKey("crudGroupOwner") ? primaryKey.Value <int?>("crudGroupOwner") : null;
int? crudGroup = null;
if (serviceFields.ContainsKey("crudGroup"))
{
crudGroup = (int)obj.GetType().GetProperty("CrudGroup").GetValue(obj);
}
foreach (var item in RequestFilter.clients)
{
RequestFilter.LoginResponse login = RequestFilter.logins[item.Key];
int?userCrudGroupOwner = login.user.CrudGroupOwner;
// enviar somente para os clients de "crudGroupOwner"
if (objCrudGroupOwner == null || userCrudGroupOwner == 1 || objCrudGroupOwner == userCrudGroupOwner)
{
// restrição de crudGroup
if (crudGroup == null || login.groups.IndexOf((int)crudGroup) >= 0)
{
// envia somente para os usuários com acesso ao serviço alterado
if (login.websocketServices.Contains(serviceName))
{
var bytes = System.Text.Encoding.UTF8.GetBytes(str);
item.Value.SendAsync(new System.ArraySegment <byte> (bytes), WebSocketMessageType.Text, true, CancellationToken.None).ContinueWith(taskWS => {
if (taskWS.Exception != null)
{
Console.WriteLine("notify error, user {0} : {1}\n", login.user.Name, taskWS.Exception.InnerException.Message);
}
else
{
Console.WriteLine("notify successful, user {0} : {1}\n", login.user.Name, msg);
}
});
}
}
}
}
}
// filter
public async Task InvokeAsync(HttpContext requestContext)
{
Task Respond(ActionResult actionResult)
{
ContentResult contentResult = (Microsoft.AspNetCore.Mvc.ContentResult)actionResult;
requestContext.Response.StatusCode = (int)contentResult.StatusCode;
if (contentResult.ContentType != null)
{
requestContext.Response.ContentType = contentResult.ContentType;
}
if (contentResult.Content != null)
{
return(requestContext.Response.WriteAsync(contentResult.Content));
}
else
{
return(Task.CompletedTask);
}
}
String method = requestContext.Request.Method;
Console.WriteLine(String.Format("method : {0}", method));
// When HttpMethod comes as OPTIONS, just acknowledge that it accepts...
if (method.Equals("OPTIONS"))
{
// Just send a OK signal back to the browser
requestContext.Response.StatusCode = 200;
// TODO : habilitar somente os IPs dos servidores instalados nas empresas
//responseContext.getHeaders().add("Access-Control-Allow-Origin", "*"); // USE * for all, https://localhost:9443
//responseContext.getHeaders().add("Access-Control-Allow-Methods", "PUT,DELETE"); // GET, POST, HEAD, OPTIONS
//responseContext.getHeaders().add("Access-Control-Allow-Headers", "Authorization, Origin, X-Requested-With, Content-Type");
//// responseContext.getHeaders().add("Access-Control-Expose-Headers", "Location, Content-Disposition");
//// responseContext.getHeaders().add("Access-Control-Allow-Credentials", "true" );
return;
}
String ip = requestContext.Connection.RemoteIpAddress.ToString();
String uri = requestContext.Request.Path.ToUriComponent();
String[] paths = uri.Split('/');
String root = paths [1];
String resource = null;
String action = null;
if (root.Equals("rest") == true)
{
if (paths.Length > 2)
{
resource = CaseConvert.UnderscoreToCamel(paths [2], false);
if (paths.Length > 3)
{
action = paths [3];
}
}
}
Console.WriteLine(String.Format("RemoteAddr : {0}", ip));
Console.WriteLine(String.Format("uri : {0}", uri));
Console.WriteLine(String.Format("root : {0}", root));
Console.WriteLine(String.Format("resource : {0}", resource));
Console.WriteLine(String.Format("action : {0}", action));
DbContext entityManager = (DbContext)requestContext.RequestServices.GetService(typeof(CrudContext));
// no login pede usuário e senha
if (root.Equals("rest"))
{
if (resource.Equals("authc"))
{
await this.AuthenticateByUserAndPassword(entityManager, requestContext, ip).ContinueWith <Task>(taskAuthenticate => {
ActionResult response = taskAuthenticate.Result;
return(Respond(response));
}).Result;
// em qualquer outro método pede o token
}
else
{
ActionResult response = this.ProcessRequest(requestContext, entityManager, resource, action);
if (response != null)
{
await Respond(response);
}
else
{
await this.next(requestContext);
}
}
}
else if (root.Equals("websocket"))
{
if (requestContext.WebSockets.IsWebSocketRequest)
{
await requestContext.WebSockets.AcceptWebSocketAsync().ContinueWith <WebSocketMessageType>(taskAccept => {
WebSocket webSocket = taskAccept.Result;
var buffer = new byte[1024 * 4];
// READ TOKEN
return(webSocket.ReceiveAsync(new ArraySegment <byte>(buffer), CancellationToken.None).ContinueWith <WebSocketMessageType>(taskToken => {
if (taskToken.Result.MessageType == WebSocketMessageType.Text)
{
String token = Encoding.UTF8.GetString(buffer, 0, taskToken.Result.Count);
this.OnMessage(webSocket, token);
// READ DISCONECT
return webSocket.ReceiveAsync(new ArraySegment <byte>(buffer), CancellationToken.None).ContinueWith <WebSocketMessageType>(taskClose => {
if (taskClose.Result.MessageType == WebSocketMessageType.Close)
{
this.OnClose(webSocket, token);
}
return taskClose.Result.MessageType;
}).Result;
}
else
{
return taskToken.Result.MessageType;
}
}).Result);
});
}
else
{
requestContext.Response.StatusCode = StatusCodes.Status400BadRequest;
}
}
else
{
await this.next(requestContext);
}
// Call the next delegate/middleware in the pipeline
}
public Task <ActionResult> Create([FromBody] RequestProduct obj)
{
String serviceName = CaseConvert.UnderscoreToCamel(obj.GetType().Name, false);
return(RequestFilter.ProcessCreate <RequestProduct>(this.User.Identity, this.entityManager, serviceName, obj));
}
