Ejemplo n.º 1
0
        public async Task <ActionResult <ApiResponse> > GetAppEntities(string withFieldName, string withFieldValue)
        {
            try
            {
                var modelResults = new List <AppEntityModel>();
                var results      = await _repo.GetAllEntitiesAsync();

                foreach (var entity in results)
                {
                    AppEntityModel model = new AppEntityModel()
                    {
                        Id       = entity.Id,
                        TypeId   = entity.Type.Id,
                        TypeName = entity.Type.Name
                    };

                    model.Fields = new List <AppEntityDataFieldModel>();
                    bool foundFieldNameValueCombo = false;
                    foreach (var field in entity.Fields)
                    {
                        var fieldModel = new AppEntityDataFieldModel()
                        {
                            FieldId = field.Id,
                            Name    = field.Name,
                            Section = field.Section
                        };

                        switch (field.GetType().Name)
                        {
                        case "AppEntityDataFieldText":
                            fieldModel.FieldType = DataFieldTypeEnum.Text;
                            fieldModel.TextValue = ((AppEntityDataFieldText)field).Value;
                            if (field.Name == "Nome")
                            {
                                model.Name = fieldModel.TextValue;
                            }

                            if (!string.IsNullOrEmpty(withFieldName) && !string.IsNullOrEmpty(withFieldValue) &&
                                fieldModel.Name.Normalize().ToUpper().Contains(withFieldName.Trim().Normalize().ToUpper()) &&
                                fieldModel.TextValue.Normalize().ToUpper().Contains(withFieldValue.Trim().Normalize().ToUpper()))
                            {
                                foundFieldNameValueCombo = true;
                            }

                            break;

                        case "AppEntityDataFieldNumber":
                            fieldModel.FieldType   = DataFieldTypeEnum.Number;
                            fieldModel.NumberValue = ((AppEntityDataFieldNumber)field).Value;

                            if (!string.IsNullOrEmpty(withFieldName) && !string.IsNullOrEmpty(withFieldValue) && int.TryParse(withFieldValue, out int a) &&
                                fieldModel.Name.Normalize().ToUpper().Contains(withFieldName.Trim().Normalize().ToUpper()) &&
                                fieldModel.NumberValue == int.Parse(withFieldValue))
                            {
                                foundFieldNameValueCombo = true;
                            }

                            break;

                        case "AppEntityDataFieldDate":
                            fieldModel.FieldType = DataFieldTypeEnum.Date;
                            fieldModel.DateValue = ((AppEntityDataFieldDate)field).Value.ToString("yyyy-MM-dd");

                            if (!string.IsNullOrEmpty(withFieldName) && !string.IsNullOrEmpty(withFieldValue) &&
                                fieldModel.Name.Normalize().ToUpper().Contains(withFieldName.Trim().Normalize().ToUpper()) &&
                                fieldModel.DateValue == withFieldValue)
                            {
                                foundFieldNameValueCombo = true;
                            }

                            break;

                        case "AppEntityDataFieldCombobox":
                            fieldModel.FieldType        = DataFieldTypeEnum.Combobox;
                            fieldModel.ComboboxSelected = ((AppEntityDataFieldCombobox)field).SelectedOption;
                            fieldModel.ComboboxOptions  = new List <string>();
                            foreach (var option in await _repo.GetDataFieldComboboxOptionsAsync(fieldModel.FieldId))
                            {
                                fieldModel.ComboboxOptions.Add(option.Name);
                            }

                            if (!string.IsNullOrEmpty(withFieldName) && !string.IsNullOrEmpty(withFieldValue) &&
                                fieldModel.Name.Normalize().ToUpper().Contains(withFieldName.Trim().Normalize().ToUpper()) &&
                                fieldModel.ComboboxOptions[fieldModel.ComboboxSelected].Normalize().ToUpper().Contains(withFieldValue.Trim().Normalize().ToUpper()))
                            {
                                foundFieldNameValueCombo = true;
                            }

                            break;

                        case "AppEntityDataFieldBoolean":
                            fieldModel.FieldType    = DataFieldTypeEnum.Boolean;
                            fieldModel.BooleanValue = ((AppEntityDataFieldBoolean)field).Value;

                            if (!string.IsNullOrEmpty(withFieldName) && !string.IsNullOrEmpty(withFieldValue) && int.TryParse(withFieldValue, out int b) &&
                                fieldModel.Name.Normalize().ToUpper().Contains(withFieldName.Trim().Normalize().ToUpper()))
                            {
                                if (int.Parse(withFieldValue) == 0 && fieldModel.BooleanValue == false || int.Parse(withFieldValue) == 1 && fieldModel.BooleanValue == true)
                                {
                                    foundFieldNameValueCombo = true;
                                }
                            }

                            break;
                        }

                        model.Fields.Add(fieldModel);
                    }

                    var foundRelations = await _repo.GetEntityRelationsAsync(entity.Id);

                    model.Relations = new List <AppEntityRelationModel>();
                    foreach (var relation in foundRelations)
                    {
                        var relationModel = new AppEntityRelationModel()
                        {
                            Id          = relation.Id,
                            Description = relation.Description
                        };

                        AppEntity foundRelatedEntity = null;
                        if (relation.Entity.Id == entity.Id)
                        {
                            foundRelatedEntity = await _repo.GetEntityByIdAsync(relation.relatedEntityId, true);
                        }
                        else if (relation.relatedEntityId == entity.Id)
                        {
                            foundRelatedEntity = relation.Entity;
                        }

                        relationModel.RelatedEntity = new AppEntityModel()
                        {
                            Id       = foundRelatedEntity.Id,
                            Name     = ((AppEntityDataFieldText)foundRelatedEntity.Fields.First(t => t.Name == "Nome")).Value,
                            TypeName = foundRelatedEntity.Type.Name
                        };

                        model.Relations.Add(relationModel);
                    }

                    if (string.IsNullOrEmpty(withFieldName) && string.IsNullOrEmpty(withFieldValue))
                    {
                        modelResults.Add(model);
                    }
                    else if (!string.IsNullOrEmpty(withFieldName) && !string.IsNullOrEmpty(withFieldValue) && foundFieldNameValueCombo)
                    {
                        modelResults.Add(model);
                    }
                }

                return(Ok(new ApiResponse <List <AppEntityModel> >(StatusCodes.Status200OK, "OK", modelResults)));
            }
            catch (Exception)
            {
                return(this.StatusCode(StatusCodes.Status500InternalServerError, "Erro interno do servidor."));
            }
        }
Ejemplo n.º 2
0
        public async Task <ActionResult <ApiResponse> > GetEntity(int id, bool includeFields = true)
        {
            try
            {
                var entity = await _repo.GetEntityByIdAsync(id, includeFields);

                if (entity == null)
                {
                    return(NotFound(new ApiResponse(StatusCodes.Status404NotFound, "Erro! Essa entidade não existe.")));
                }

                var modelResult = new AppEntityModel()
                {
                    Id       = entity.Id,
                    TypeId   = entity.Type.Id,
                    TypeName = entity.Type.Name
                };

                if (includeFields)
                {
                    modelResult.Fields = new List <AppEntityDataFieldModel>();
                    foreach (var field in entity.Fields)
                    {
                        var fieldModel = new AppEntityDataFieldModel()
                        {
                            FieldId = field.Id,
                            Name    = field.Name,
                            Section = field.Section
                        };

                        switch (field.GetType().Name)
                        {
                        case "AppEntityDataFieldText":
                            fieldModel.FieldType = DataFieldTypeEnum.Text;
                            fieldModel.TextValue = ((AppEntityDataFieldText)field).Value;
                            if (field.Name == "Nome")
                            {
                                modelResult.Name = fieldModel.TextValue;
                            }

                            break;

                        case "AppEntityDataFieldNumber":
                            fieldModel.FieldType   = DataFieldTypeEnum.Number;
                            fieldModel.NumberValue = ((AppEntityDataFieldNumber)field).Value;
                            break;

                        case "AppEntityDataFieldDate":
                            fieldModel.FieldType = DataFieldTypeEnum.Date;
                            fieldModel.DateValue = ((AppEntityDataFieldDate)field).Value.ToString("yyyy-MM-dd");
                            break;

                        case "AppEntityDataFieldCombobox":
                            fieldModel.FieldType        = DataFieldTypeEnum.Combobox;
                            fieldModel.ComboboxSelected = ((AppEntityDataFieldCombobox)field).SelectedOption;
                            fieldModel.ComboboxOptions  = new List <string>();
                            foreach (var option in await _repo.GetDataFieldComboboxOptionsAsync(fieldModel.FieldId))
                            {
                                fieldModel.ComboboxOptions.Add(option.Name);
                            }
                            break;

                        case "AppEntityDataFieldBoolean":
                            fieldModel.FieldType    = DataFieldTypeEnum.Boolean;
                            fieldModel.BooleanValue = ((AppEntityDataFieldBoolean)field).Value;
                            break;
                        }

                        modelResult.Fields.Add(fieldModel);
                    }
                }

                return(Ok(new ApiResponse <AppEntityModel>(StatusCodes.Status200OK, "Ok", modelResult)));
            }
            catch (Exception)
            {
                return(this.StatusCode(StatusCodes.Status500InternalServerError, "Erro interno do servidor."));
            }
        }