Esempio n. 1
0
        public async Task Invoke(InvokeContext <TService> ctx)
        {
            IDataHelper <TService> dataHelper = ctx.ServiceContainer.GetDataHelper();
            IServiceOperationsHelper <TService> serviceHelper = ctx.ServiceContainer.GetServiceHelper();
            RunTimeMetadata   metadata = ctx.Service.GetMetadata();
            MethodDescription method   = metadata.GetInvokeMethod(ctx.Request.methodName);

            List <object> methParams = new List <object>();

            for (int i = 0; i < method.parameters.Count; ++i)
            {
                methParams.Add(ctx.Request.paramInfo.GetValue(method.parameters[i].name, method, dataHelper));
            }
            RequestContext req = InvokeContext <TService> .CreateRequestContext(ctx.Service);

            using (RequestCallContext callContext = new RequestCallContext(req))
            {
                MethodInfoData methodData   = method.GetMethodData();
                object         instance     = serviceHelper.GetMethodOwner(methodData);
                object         invokeRes    = methodData.MethodInfo.Invoke(instance, methParams.ToArray());
                object         methodResult = await serviceHelper.GetMethodResult(invokeRes);

                if (method.methodResult)
                {
                    ctx.Response.result = methodResult;
                }
            }

            await _next(ctx);
        }
Esempio n. 2
0
        public virtual string GenerateScript(string comment = null, bool isDraft = false)
        {
            RunTimeMetadata  metadata = Owner.GetMetadata();
            TypeScriptHelper helper   = new TypeScriptHelper(_serializer, _dataHelper, _valueConverter, metadata, _clientTypes());

            return(helper.CreateTypeScript(comment));
        }
Esempio n. 3
0
        public async Task Invoke(CRUDContext <TService> ctx)
        {
            IAuthorizer <TService> authorizer = ctx.ServiceContainer.GetAuthorizer();
            RunTimeMetadata        metadata   = ctx.Service.GetMetadata();

            foreach (DbSet dbSet in ctx.Request.dbSets)
            {
                //methods on domain service which are attempted to be executed by client (SaveChanges triggers their execution)
                Dictionary <string, MethodInfoData> domainServiceMethods = new Dictionary <string, MethodInfoData>();
                DbSetInfo dbInfo = metadata.DbSets[dbSet.dbSetName];

                dbSet.rows.Aggregate <RowInfo, Dictionary <string, MethodInfoData> >(domainServiceMethods, (dict, rowInfo) =>
                {
                    MethodInfoData method = rowInfo.GetCRUDMethodInfo(metadata, dbInfo.dbSetName);
                    if (method == null)
                    {
                        throw new DomainServiceException(string.Format(ErrorStrings.ERR_REC_CHANGETYPE_INVALID,
                                                                       dbInfo.GetEntityType().Name, rowInfo.changeType));
                    }

                    string dicKey = string.Format("{0}:{1}", method.OwnerType.FullName, method.MethodInfo.Name);
                    if (!dict.ContainsKey(dicKey))
                    {
                        dict.Add(dicKey, method);
                    }
                    return(dict);
                });

                await authorizer.CheckUserRightsToExecute(domainServiceMethods.Values);
            }

            await _next(ctx);
        }
Esempio n. 4
0
        public async Task Invoke(RefreshContext <TService> ctx)
        {
            DbSetInfo dbSetInfo = ctx.Request.GetDbSetInfo() ?? throw new InvalidOperationException($"Could not get the DbSet for {ctx.Request.dbSetName}");
            IServiceOperationsHelper <TService> serviceHelper = ctx.ServiceContainer.GetServiceHelper();
            RunTimeMetadata metadata = ctx.Service.GetMetadata();

            RequestContext req = RefreshContext <TService> .CreateRequestContext(ctx.Service, ctx.Request.rowInfo);

            using (RequestCallContext callContext = new RequestCallContext(req))
            {
                MethodInfoData methodData = metadata.GetOperationMethodInfo(ctx.Request.dbSetName, MethodType.Refresh);
                object         instance   = serviceHelper.GetMethodOwner(methodData);
                object         invokeRes  = methodData.MethodInfo.Invoke(instance, new object[] { ctx.Request });
                object         dbEntity   = await serviceHelper.GetMethodResult(invokeRes);

                if (dbEntity != null)
                {
                    serviceHelper.UpdateRowInfoFromEntity(dbEntity, ctx.Request.rowInfo);
                }
                else
                {
                    throw new InvalidOperationException($"Refresh Operation for {ctx.Request.dbSetName} did not return a result");
                }
            }

            await _next(ctx);
        }
        public async Task UpdateEntity(RunTimeMetadata metadata, RowInfo rowInfo)
        {
            DbSetInfo dbSetInfo = rowInfo.GetDbSetInfo();

            if (rowInfo.changeType != ChangeType.Updated)
            {
                throw new DomainServiceException(string.Format(ErrorStrings.ERR_REC_CHANGETYPE_INVALID,
                                                               dbSetInfo.GetEntityType().Name, rowInfo.changeType));
            }

            MethodInfoData methodData = metadata.GetOperationMethodInfo(dbSetInfo.dbSetName, MethodType.Update);

            if (methodData == null)
            {
                throw new DomainServiceException(string.Format(ErrorStrings.ERR_DB_UPDATE_NOT_IMPLEMENTED,
                                                               dbSetInfo.GetEntityType().Name, GetType().Name));
            }

            object dbEntity = Activator.CreateInstance(dbSetInfo.GetEntityType());

            UpdateEntityFromRowInfo(dbEntity, rowInfo, false);
            object original = GetOriginalEntity(dbEntity, rowInfo);

            rowInfo.GetChangeState().Entity         = dbEntity;
            rowInfo.GetChangeState().OriginalEntity = original;
            object instance = GetMethodOwner(methodData);
            //apply this changes to entity that is in the database (this is done in user domain service method)
            object res = methodData.MethodInfo.Invoke(instance, new[] { dbEntity });

            if (res is Task)
            {
                await(res as Task);
            }
        }
Esempio n. 6
0
        public async Task <Permissions> ServiceGetPermissions()
        {
            try
            {
                await Task.CompletedTask;
                RunTimeMetadata metadata = GetMetadata();
                Permissions     result   = new Permissions()
                {
                    serverTimezone = DateTimeHelper.GetTimezoneOffset()
                };
                IAuthorizer authorizer = ServiceContainer.Authorizer;
                foreach (DbSetInfo dbInfo in metadata.DbSets.Values)
                {
                    DbSetPermit permissions = await authorizer.GetDbSetPermissions(metadata, dbInfo.dbSetName);

                    result.permissions.Add(permissions);
                }

                return(result);
            }
            catch (Exception ex)
            {
                _OnError(ex);
                throw new DummyException(ex.GetFullMessage(), ex);
            }
        }
        public async Task DeleteEntity(RunTimeMetadata metadata, RowInfo rowInfo)
        {
            DbSetInfo dbSetInfo = rowInfo.GetDbSetInfo();

            if (rowInfo.changeType != ChangeType.Deleted)
            {
                throw new DomainServiceException(string.Format(ErrorStrings.ERR_REC_CHANGETYPE_INVALID,
                                                               dbSetInfo.GetEntityType().Name, rowInfo.changeType));
            }

            MethodInfoData methodData = metadata.GetOperationMethodInfo(dbSetInfo.dbSetName, MethodType.Delete);

            if (methodData == null)
            {
                throw new DomainServiceException(string.Format(ErrorStrings.ERR_DB_DELETE_NOT_IMPLEMENTED,
                                                               dbSetInfo.GetEntityType().Name, GetType().Name));
            }

            object dbEntity = Activator.CreateInstance(dbSetInfo.GetEntityType());

            UpdateEntityFromRowInfo(dbEntity, rowInfo, true);
            rowInfo.GetChangeState().Entity         = dbEntity;
            rowInfo.GetChangeState().OriginalEntity = dbEntity;
            object instance = GetMethodOwner(methodData);
            object res      = methodData.MethodInfo.Invoke(instance, new[] { dbEntity });

            if (res is Task)
            {
                await(res as Task);
            }
        }
Esempio n. 8
0
        public async Task Invoke(QueryContext <TService> ctx)
        {
            Security.IAuthorizer <TService> authorizer = ctx.ServiceContainer.GetAuthorizer();
            RunTimeMetadata metadata = ctx.Service.GetMetadata();

            MethodDescription method = metadata.GetQueryMethod(ctx.Request.dbSetName, ctx.Request.queryName);
            await authorizer.CheckUserRightsToExecute(method.GetMethodData());

            await _next(ctx);
        }
Esempio n. 9
0
        private async Task Delete(CRUDContext <TService> ctx, RunTimeMetadata metadata, ChangeSetRequest changeSet, RowInfo rowInfo)
        {
            TService service = ctx.Service;
            IServiceOperationsHelper <TService> serviceHelper = ctx.ServiceContainer.GetServiceHelper();

            CheckRowInfo(rowInfo);

            using (RequestCallContext callContext = new RequestCallContext(CRUDContext <TService> .CreateRequestContext(service, changeSet, rowInfo)))
            {
                rowInfo.SetChangeState(new EntityChangeState());
                await serviceHelper.DeleteEntity(metadata, rowInfo);;
            }
        }
Esempio n. 10
0
 public TypeScriptHelper(ISerializer serializer,
                         IDataHelper dataHelper,
                         IValueConverter valueConverter,
                         RunTimeMetadata metadata,
                         IEnumerable <Type> clientTypes)
 {
     _serializer     = serializer ?? throw new ArgumentNullException(nameof(serializer));
     _dataHelper     = dataHelper ?? throw new ArgumentNullException(nameof(dataHelper));
     _valueConverter = valueConverter ?? throw new ArgumentNullException(nameof(valueConverter));
     _metadata       = metadata ?? throw new ArgumentNullException(nameof(metadata));
     _clientTypes    = new List <Type>(clientTypes ?? Enumerable.Empty <Type>());
     _dbSets         = _metadata.DbSets.Values.OrderBy(v => v.dbSetName).ToList();
     _associations   = _metadata.Associations.Values.OrderBy(a => a.name).ToList();
 }
Esempio n. 11
0
        private async Task Insert(CRUDContext <TService> ctx, RunTimeMetadata metadata, ChangeSetRequest changeSet, IChangeSetGraph graph, RowInfo rowInfo)
        {
            TService service = ctx.Service;
            IServiceOperationsHelper <TService> serviceHelper = ctx.ServiceContainer.GetServiceHelper();

            CheckRowInfo(rowInfo);

            using (RequestCallContext callContext = new RequestCallContext(CRUDContext <TService> .CreateRequestContext(service, changeSet, rowInfo)))
            {
                rowInfo.SetChangeState(new EntityChangeState {
                    ParentRows = graph.GetParents(rowInfo)
                });
                await serviceHelper.InsertEntity(metadata, rowInfo);
            }
        }
Esempio n. 12
0
        public async Task Invoke(CRUDContext <TService> ctx)
        {
            IServiceOperationsHelper <TService> serviceHelper = ctx.ServiceContainer.GetServiceHelper();
            RunTimeMetadata  metadata  = ctx.Service.GetMetadata();
            ChangeSetRequest changeSet = ctx.Request;

            ChangeSetGraph graph = new ChangeSetGraph(ctx.Request, metadata);

            graph.Prepare();
            ctx.Properties.Add(CRUDContext <TService> .CHANGE_GRAPH_KEY, graph);

            RowInfo currentRowInfo = null;

            try
            {
                foreach (RowInfo rowInfo in graph.InsertList)
                {
                    currentRowInfo = rowInfo;
                    await Insert(ctx, metadata, changeSet, graph, rowInfo);
                }

                foreach (RowInfo rowInfo in graph.UpdateList)
                {
                    currentRowInfo = rowInfo;
                    await Update(ctx, metadata, changeSet, rowInfo);
                }

                foreach (RowInfo rowInfo in graph.DeleteList)
                {
                    currentRowInfo = rowInfo;
                    await Delete(ctx, metadata, changeSet, rowInfo);
                }
            }
            catch (Exception ex)
            {
                if (currentRowInfo != null)
                {
                    object dbEntity = currentRowInfo.GetChangeState()?.Entity;
                    currentRowInfo.SetChangeState(new EntityChangeState {
                        Entity = dbEntity, Error = ex
                    });
                }
                throw;
            }

            await _next(ctx);
        }
        public static string CreateMethods(RunTimeMetadata metadata, DbContext DB)
        {
            StringBuilder sb = new StringBuilder(4096);

            System.Collections.Generic.List <DbSetInfo> dbSets = metadata.DbSets.Values.OrderBy(d => d.dbSetName).ToList();
            dbSets.ForEach(dbSetInfo =>
            {
                string tableName = GetTableName(DB, dbSetInfo.GetEntityType());
                if (tableName == string.Empty)
                {
                    return;
                }

                sb.AppendLine(CreateDbSetMethods(dbSetInfo, tableName));
            });
            return(sb.ToString());
        }
        public object GetMethodOwner(MethodInfoData methodData)
        {
            if (!methodData.IsInDataManager)
            {
                return(_domainService);
            }

            if (methodData.EntityType == null)
            {
                return(_domainService);
            }

            RunTimeMetadata metadata        = _domainService.GetMetadata();
            object          managerInstance = _dataManagers.GetOrAdd(methodData.EntityType,
                                                                     t => { return(_dataManagerContainer.GetDataManager(t)); });

            return(managerInstance);
        }
Esempio n. 15
0
 public MetadataResult ServiceGetMetadata()
 {
     try
     {
         RunTimeMetadata metadata = GetMetadata();
         MetadataResult  result   = new MetadataResult()
         {
             methods = metadata.MethodDescriptions
         };
         result.associations.AddRange(metadata.Associations.Values);
         result.dbSets.AddRange(metadata.DbSets.Values.OrderBy(d => d.dbSetName));
         return(result);
     }
     catch (Exception ex)
     {
         _OnError(ex);
         throw new DummyException(ex.GetFullMessage(), ex);
     }
 }
Esempio n. 16
0
        public async Task Invoke(CRUDContext <TService> ctx)
        {
            RunTimeMetadata  metadata  = ctx.Service.GetMetadata();
            ChangeSetRequest changeSet = ctx.Request;

            IChangeSetGraph graph = ctx.Properties.Get <IChangeSetGraph>(CRUDContext <TService> .CHANGE_GRAPH_KEY) ?? throw new InvalidOperationException("Could not get Graph changes from properties");

            if (!await ValidateRows(ctx, changeSet, metadata, graph.InsertList))
            {
                throw new ValidationException(ErrorStrings.ERR_SVC_CHANGES_ARENOT_VALID);
            }

            if (!await ValidateRows(ctx, changeSet, metadata, graph.UpdateList))
            {
                throw new ValidationException(ErrorStrings.ERR_SVC_CHANGES_ARENOT_VALID);
            }

            await _next(ctx);
        }
Esempio n. 17
0
        public async Task Invoke(RefreshContext <TService> ctx)
        {
            DbSetInfo dbSetInfo = ctx.Request.GetDbSetInfo() ?? throw new InvalidOperationException($"Could not get the DbSet for {ctx.Request.dbSetName}");

            Security.IAuthorizer <TService> authorizer = ctx.ServiceContainer.GetAuthorizer();
            RunTimeMetadata metadata = ctx.Service.GetMetadata();

            MethodInfoData methodData = metadata.GetOperationMethodInfo(ctx.Request.dbSetName, MethodType.Refresh);

            if (methodData == null)
            {
                throw new InvalidOperationException(string.Format(ErrorStrings.ERR_REC_REFRESH_INVALID,
                                                                  dbSetInfo.GetEntityType().Name, GetType().Name));
            }

            await authorizer.CheckUserRightsToExecute(methodData);

            await _next(ctx);
        }
Esempio n. 18
0
        public async Task Invoke(QueryContext <TService> ctx)
        {
            DbSetInfo dbSetInfo = ctx.Request.GetDbSetInfo() ?? throw new InvalidOperationException($"Could not get the DbSet for {ctx.Request.dbSetName}");
            IDataHelper <TService> dataHelper = ctx.ServiceContainer.GetDataHelper();
            IServiceOperationsHelper <TService> serviceHelper = ctx.ServiceContainer.GetServiceHelper();
            RunTimeMetadata metadata = ctx.Service.GetMetadata();

            MethodDescription method = metadata.GetQueryMethod(ctx.Request.dbSetName, ctx.Request.queryName);

            LinkedList <object> methParams = new LinkedList <object>();

            for (int i = 0; i < method.parameters.Count; ++i)
            {
                methParams.AddLast(ctx.Request.paramInfo.GetValue(method.parameters[i].name, method, dataHelper));
            }

            RequestContext req = QueryContext <TService> .CreateRequestContext(ctx.Service, ctx.Request);

            using (RequestCallContext callContext = new RequestCallContext(req))
            {
                MethodInfoData methodData  = method.GetMethodData();
                object         instance    = serviceHelper.GetMethodOwner(methodData);
                object         invokeRes   = methodData.MethodInfo.Invoke(instance, methParams.ToArray());
                QueryResult    queryResult = (QueryResult)await serviceHelper.GetMethodResult(invokeRes);

                IEnumerable <object> entities  = queryResult.Result;
                int?              totalCount   = queryResult.TotalCount;
                RowGenerator      rowGenerator = new RowGenerator(dbSetInfo, entities, dataHelper);
                IEnumerable <Row> rows         = rowGenerator.CreateRows();

                SubsetsGenerator subsetsGenerator = new SubsetsGenerator(metadata, dataHelper);
                SubsetList       subResults       = subsetsGenerator.CreateSubsets(queryResult.subResults);

                ctx.Response.names      = dbSetInfo.GetNames();
                ctx.Response.totalCount = totalCount;
                ctx.Response.rows       = rows;
                ctx.Response.subsets    = subResults;
                ctx.Response.extraInfo  = queryResult.extraInfo;
            }

            await _next(ctx);
        }
Esempio n. 19
0
        public static MethodInfoData GetCRUDMethodInfo(this RowInfo rowInfo, RunTimeMetadata metadata, string dbSetName)
        {
            MethodInfoData method = null;

            switch (rowInfo.changeType)
            {
            case ChangeType.Added:
                method = metadata.GetOperationMethodInfo(dbSetName, MethodType.Insert);
                break;

            case ChangeType.Deleted:
                method = metadata.GetOperationMethodInfo(dbSetName, MethodType.Delete);
                break;

            case ChangeType.Updated:
                method = metadata.GetOperationMethodInfo(dbSetName, MethodType.Update);
                break;

            default:
                throw new DomainServiceException(string.Format(ErrorStrings.ERR_REC_CHANGETYPE_INVALID, dbSetName,
                                                               rowInfo.changeType));
            }
            return(method);
        }
Esempio n. 20
0
 public ChangeSetGraph(ChangeSetRequest changeSet, RunTimeMetadata metadata)
 {
     ChangeSet = changeSet ?? throw new ArgumentNullException(nameof(changeSet));
     _metadata = metadata ?? throw new ArgumentNullException(nameof(metadata));
 }
Esempio n. 21
0
        public static async Task <bool> CanAccessOperation(this IAuthorizer authorizer, RunTimeMetadata metadata, string dbSetName, MethodType methodType)
        {
            MethodInfoData method = metadata.GetOperationMethodInfo(dbSetName, methodType);

            return(method != null && await authorizer.CanAccessMethod(method));
        }
Esempio n. 22
0
 public static async Task <DbSetPermit> GetDbSetPermissions(this IAuthorizer authorizer, RunTimeMetadata metadata, string dbSetName)
 {
     return(new DbSetPermit()
     {
         dbSetName = dbSetName,
         canAddRow = await authorizer.CanAccessOperation(metadata, dbSetName, MethodType.Insert),
         canEditRow = await authorizer.CanAccessOperation(metadata, dbSetName, MethodType.Update),
         canDeleteRow = await authorizer.CanAccessOperation(metadata, dbSetName, MethodType.Delete),
         canRefreshRow = await authorizer.CanAccessOperation(metadata, dbSetName, MethodType.Refresh)
     });
 }
Esempio n. 23
0
        private async Task <bool> ValidateRows(CRUDContext <TService> ctx, ChangeSetRequest changeSet, RunTimeMetadata metadata, IEnumerable <RowInfo> rows)
        {
            TService service = ctx.Service;
            IServiceOperationsHelper <TService> serviceHelper = ctx.ServiceContainer.GetServiceHelper();

            foreach (RowInfo rowInfo in rows)
            {
                RequestContext req = CRUDContext <TService> .CreateRequestContext(service, changeSet, rowInfo);

                using (RequestCallContext callContext = new RequestCallContext(req))
                {
                    if (!await serviceHelper.ValidateEntity(metadata, req))
                    {
                        rowInfo.invalid = rowInfo.GetChangeState().ValidationErrors;
                        return(false);
                    }
                }
            }
            return(true);
        }
Esempio n. 24
0
 public SubsetsGenerator(RunTimeMetadata metadata, IDataHelper dataHelper)
 {
     _metadata   = metadata ?? throw new ArgumentNullException(nameof(metadata));
     _dataHelper = dataHelper ?? throw new ArgumentNullException(nameof(dataHelper));
 }
        public async Task <bool> ValidateEntity(RunTimeMetadata metadata, RequestContext requestContext)
        {
            RowInfo   rowInfo   = requestContext.CurrentRowInfo;
            DbSetInfo dbSetInfo = rowInfo.GetDbSetInfo();
            IEnumerable <ValidationErrorInfo> errs1 = null;
            IEnumerable <ValidationErrorInfo> errs2 = null;
            LinkedList <string> mustBeChecked       = new LinkedList <string>();
            LinkedList <string> skipCheckList       = new LinkedList <string>();

            if (rowInfo.changeType == ChangeType.Added)
            {
                foreach (ParentChildNode pn in rowInfo.GetChangeState().ParentRows)
                {
                    foreach (FieldRel frel in pn.Association.fieldRels)
                    {
                        skipCheckList.AddLast(frel.childField);
                    }
                }
            }

            foreach (Field fieldInfo in dbSetInfo.fieldInfos)
            {
                _dataHelper.ForEachFieldInfo("", fieldInfo, (fullName, f) =>
                {
                    if (!f.GetIsIncludeInResult())
                    {
                        return;
                    }

                    if (f.fieldType == FieldType.Object || f.fieldType == FieldType.ServerCalculated)
                    {
                        return;
                    }

                    string value = _dataHelper.SerializeField(rowInfo.GetChangeState().Entity, fullName, f);

                    switch (rowInfo.changeType)
                    {
                    case ChangeType.Added:
                        {
                            bool isSkip = f.isAutoGenerated || skipCheckList.Any(n => n == fullName);
                            if (!isSkip)
                            {
                                _validationHelper.CheckValue(f, value);
                                mustBeChecked.AddLast(fullName);
                            }
                        }
                        break;

                    case ChangeType.Updated:
                        {
                            bool isChanged = isEntityValueChanged(rowInfo, fullName, f, out string newVal);
                            if (isChanged)
                            {
                                _validationHelper.CheckValue(f, newVal);
                                mustBeChecked.AddLast(fullName);
                            }
                        }
                        break;
                    }
                });
            }

            rowInfo.GetChangeState().ChangedFieldNames = mustBeChecked.ToArray();

            MethodInfoData methodData = metadata.GetOperationMethodInfo(dbSetInfo.dbSetName, MethodType.Validate);

            if (methodData != null)
            {
                object instance  = GetMethodOwner(methodData);
                object invokeRes = methodData.MethodInfo.Invoke(instance,
                                                                new[] { rowInfo.GetChangeState().Entity, rowInfo.GetChangeState().ChangedFieldNames });
                errs1 = (IEnumerable <ValidationErrorInfo>) await GetMethodResult(invokeRes);
            }

            if (errs1 == null)
            {
                errs1 = Enumerable.Empty <ValidationErrorInfo>();
            }

            IValidator validator = _validatorsContainer.GetValidator(rowInfo.GetDbSetInfo().GetEntityType());

            if (validator != null)
            {
                errs2 = await validator.ValidateModelAsync(rowInfo.GetChangeState().Entity,
                                                           rowInfo.GetChangeState().ChangedFieldNames);
            }

            if (errs2 == null)
            {
                errs2 = Enumerable.Empty <ValidationErrorInfo>();
            }

            errs1 = errs1.Concat(errs2);

            rowInfo.GetChangeState().ValidationErrors = errs1.ToArray();

            return(rowInfo.GetChangeState().ValidationErrors.Length == 0);
        }