Data

Tools

Indexes

Applications

Experiments

Awesome

An open API service indexing awesome lists of open source software.

https://github.com/adelelawady/divinesign

DivineSign is a tool for exploring numerical patterns and word occurrences in the Quran. It offers an intuitive platform for searching and analyzing word frequencies, helping users uncover meaningful patterns and connections to reveal deeper insights and significance within the text.
https://github.com/adelelawady/divinesign

Last synced: about 1 year ago
JSON representation

DivineSign is a tool for exploring numerical patterns and word occurrences in the Quran. It offers an intuitive platform for searching and analyzing word frequencies, helping users uncover meaningful patterns and connections to reveal deeper insights and significance within the text.

Awesome Lists containing this project

README 

          
# divineSign





  muslim icon




### DivineSign v1.0 Beta



You can download the latest version of DivineSign here:



[Download DivineSign v1.0 Beta](https://github.com/adelelawady/DivineSign/releases/download/v1.0/DivineSign.v1.0.beta.exe)



# DivineSign: Unlocking the Miraculous Patterns in the Quran



DivineSign is a specialized tool designed to help users explore and uncover numerical patterns and word occurrences within the verses of the Quran. By providing an intuitive platform for searching and analyzing words and their frequency, DivineSign makes it easy to identify meaningful patterns and connections that reveal deeper layers of significance within the text.



## Technologies Used



BeatStream is built using:



- **Java** for the backend.

- **Spring Boot** for building the application.

- **JHipster** for rapid development and scaffolding.

- **Angular** (if applicable) for the front end.

- **MongoDb** (or your preferred database) for data persistence.

- **electron** For Windows APP

- 

## Requirements



To run BeatStream, you will need:



- ☕ Java Development Kit (JDK) 11 or later

- **Node.js** and **npm**

- 🐱‍🏍 **MongoDB:** Ensure that you have MongoDB running, as BeatStream uses it for data storage.



## Installation



1. 🛠️ **Clone the repository:**

   ```bash

   git clone https://github.com/adelelawady/DivineSign.git

   cd DivineSign

   ./mvnw

   ```



# Usage



🚀 Access the application:

Open your web browser and navigate to http://localhost:8080.

📖 Follow the on-screen instructions to download tracks, upload songs, and manage your library.



# API Documentation



For API documentation, visit http://localhost:8080/swagger-ui/.



# Contributing



🤝 Contributions are welcome! If you have suggestions for improvements or new features, feel free to fork the repository and submit a pull request.



# License



📝 This project is licensed under the MIT License - see the LICENSE file for details.



### Description:

This is a screenshot captured from the local environment. It showcases the user interface of the DivineSign tool, where users can explore numerical patterns and word occurrences in Quranic verses. The UI design ensures a smooth and intuitive user experience for pattern analysis.



  screencapture






  screencapture




## Key Features



### Effortless Search for Word and Number Matches



DivineSign enables users to search for specific words or numbers throughout the Quran, allowing for an efficient exploration of instances and patterns. Whether you’re interested in the occurrences of a particular word, the symmetry of certain phrases, or numerical relationships, DivineSign provides instant results to aid in your discovery.



### Splend Creation



Users can create a **“Splend”** — a shareable post that captures their findings, insights, or interpretations related to specific verses and patterns. Each Splend provides a structured format to highlight the verse(s), the pattern or match found, and any related reflections or explanations, making it easy to share with others within the app community or on social media.



### Engaging Community Features



DivineSign includes a built-in social aspect, allowing users to engage with each other's Splends. Users can like and comment on posts, sparking meaningful discussions and fostering a sense of community among those exploring the Quran's intricacies.



### Curated Reference Section



A reference section provides users with links to classic interpretations, linguistic resources, and mathematical analyses, enhancing their understanding of the patterns they discover. This ensures that DivineSign is not only a tool for discovery but also a gateway to learning.



### User-Friendly Interface



With a sleek and user-friendly interface, DivineSign is designed for both casual readers and dedicated researchers. The app is structured to make the search process simple and engaging, and its social features keep users connected in a supportive and inspiring community.



### App Versioning and Updates



DivineSign is committed to continuous improvement. Each new version incorporates user feedback, enhances search capabilities, and introduces additional features to support users in their journey of discovery.



## About DivineSign



DivineSign was created with love and a dedication to making the study of the Quran accessible, interactive, and meaningful. We believe that the beauty of the Quran lies not only in its words but also in the hidden patterns that offer glimpses into a deeper understanding of its message.



References Used



## References Used



The DivineSign app leverages carefully curated resources to ensure accurate, efficient, and accessible search capabilities. To achieve this, we utilized the open-source project [Quran JSON by Risan](https://github.com/risan/quran-json), which provides a comprehensive and well-organized digital format of the Quran. This project includes every verse and Surah, structured in JSON format, allowing for precise retrieval and handling of the text.



For seamless search functionality, each verse and Surah was stored in a MongoDB database, enabling quick and flexible querying using regular expressions (regex). This setup allows users to search for words, numbers, or patterns within the text with minimal delay, enhancing the user experience by providing immediate search results.



To accommodate various search preferences, we created an additional version of each verse by removing diacritical marks and other formations from the original Arabic text. This "formation-free" version enables users to search accurately in Arabic without needing exact matches to all marks, ensuring that searches are intuitive and effective.



Together, these resources and methods support DivineSign's mission of making it easy to explore and engage with the Quran in meaningful ways, allowing users to uncover patterns and insights with accuracy and ease.



How It Works



## How It Works



DivineSign is designed to make it easy to explore word patterns, numerical matches, and hidden connections in the Quran. Whether you’re a casual reader, a dedicated researcher, or simply curious, you can follow these simple steps to start discovering insights.



### 1\. Search for Words or Numbers



Begin by entering a word or number into the search bar. DivineSign will instantly scan the Quran to show you all instances where your search term appears, along with its frequency, location, and any notable patterns related to it. This feature lets you observe the arrangement and repetition of words in ways you may not have noticed before.



### 2\. Discover Patterns



Once you have your search results, DivineSign highlights patterns such as symmetrical phrases, numerical consistencies, or verse structures that align with your search. These visual representations make it easy to identify and reflect on the significance of certain recurring themes.



### 3\. Create a Splend



When you find an intriguing pattern, you can create a **Splend** — a post that captures and shares your discovery with others. Each Splend allows you to add reflections, highlight key verses, and provide explanations. This feature is ideal for documenting your findings and sharing insights with the DivineSign community.



### 4\. Engage with the Community



DivineSign is more than a tool; it's a community of learners and explorers. After creating a Splend, you can engage with other users by liking and commenting on their posts. Join discussions on patterns and findings, share ideas, and build connections with others who are passionate about discovering the Quran’s hidden intricacies.



### 5\. Reference and Further Study



For deeper understanding, the Reference section provides links to classic interpretations, linguistic resources, and mathematical analyses of the Quran’s text. This section acts as a bridge to traditional knowledge, enriching your exploration and providing additional context for the patterns you uncover.



Developer Information



# About Me



Hello! I'm a dedicated programmer with expertise in Java and C#, working on a variety of projects that blend powerful backend logic with user-friendly frontend applications. I enjoy creating solutions that streamline complex processes and make technology accessible and effective for users.



## Current Projects



Currently, I’m developing **DivineSign**, an innovative web application that allows users to search for specific word patterns, numerical matches, and hidden connections within the Quran. Using resources like the [Quran JSON](https://github.com/risan/quran-json) project and a MongoDB database, I’ve implemented advanced search capabilities that offer users a unique way to engage with the text. DivineSign also features social elements, allowing users to create and share insights through "Splends," which other users can like and comment on.



## Development Focus



I have a strong interest in backend architecture, particularly in creating scalable and efficient data processing systems. My current projects also involve building full-stack applications, including a music streaming app and an ERP program. I am always looking to expand my skills, including working with frameworks like Spring Boot, DevExpress, and tools like MongoDB.



## Contact Information



Feel free to reach out if you’d like to discuss potential collaborations, project ideas, or just to connect!



- Email: adel50ali50@gmail.com

- LinkedIn: [linkedin.com/in/adelelawady](https://linkedin.com/in/adelelawady)

- GitHub: [github.com/adelelawady](https://github.com/adelelawady)



This application was generated using JHipster 8.7.1, you can find documentation and help at [https://www.jhipster.tech/documentation-archive/v8.7.1](https://www.jhipster.tech/documentation-archive/v8.7.1).



## Project Structure



Node is required for generation and recommended for development. `package.json` is always generated for a better development experience with prettier, commit hooks, scripts and so on.



In the project root, JHipster generates configuration files for tools like git, prettier, eslint, husky, and others that are well known and you can find references in the web.



`/src/*` structure follows default Java structure.



- `.yo-rc.json` - Yeoman configuration file

  JHipster configuration is stored in this file at `generator-jhipster` key. You may find `generator-jhipster-*` for specific blueprints configuration.

- `.yo-resolve` (optional) - Yeoman conflict resolver

  Allows to use a specific action when conflicts are found skipping prompts for files that matches a pattern. Each line should match `[pattern] [action]` with pattern been a [Minimatch](https://github.com/isaacs/minimatch#minimatch) pattern and action been one of skip (default if omitted) or force. Lines starting with `#` are considered comments and are ignored.

- `.jhipster/*.json` - JHipster entity configuration files



- `npmw` - wrapper to use locally installed npm.

  JHipster installs Node and npm locally using the build tool by default. This wrapper makes sure npm is installed locally and uses it avoiding some differences different versions can cause. By using `./npmw` instead of the traditional `npm` you can configure a Node-less environment to develop or test your application.

- `/src/main/docker` - Docker configurations for the application and services that the application depends on



## Development



### Doing API-First development using openapi-generator-cli



[OpenAPI-Generator]() is configured for this application. You can generate API code from the `src/main/resources/swagger/api.yml` definition file by running:



```bash

./mvnw generate-sources

```



Then implements the generated delegate classes with `@Service` classes.



To edit the `api.yml` definition file, you can use a tool such as [Swagger-Editor](). Start a local instance of the swagger-editor using docker by running: `docker compose -f src/main/docker/swagger-editor.yml up -d`. The editor will then be reachable at [http://localhost:7742](http://localhost:7742).



Refer to [Doing API-First development][] for more details.

The build system will install automatically the recommended version of Node and npm.



We provide a wrapper to launch npm.

You will only need to run this command when dependencies change in [package.json](package.json).



```

./npmw install

```



We use npm scripts and [Angular CLI][] with [Webpack][] as our build system.



Run the following commands in two separate terminals to create a blissful development experience where your browser

auto-refreshes when files change on your hard drive.



```

./mvnw

./npmw start

```



Npm is also used to manage CSS and JavaScript dependencies used in this application. You can upgrade dependencies by

specifying a newer version in [package.json](package.json). You can also run `./npmw update` and `./npmw install` to manage dependencies.

Add the `help` flag on any command to see how you can use it. For example, `./npmw help update`.



The `./npmw run` command will list all the scripts available to run for this project.



### PWA Support



JHipster ships with PWA (Progressive Web App) support, and it's turned off by default. One of the main components of a PWA is a service worker.



The service worker initialization code is disabled by default. To enable it, uncomment the following code in `src/main/webapp/app/app.config.ts`:



```typescript

ServiceWorkerModule.register('ngsw-worker.js', { enabled: false }),

```



### Managing dependencies



For example, to add [Leaflet][] library as a runtime dependency of your application, you would run following command:



```

./npmw install --save --save-exact leaflet

```



To benefit from TypeScript type definitions from [DefinitelyTyped][] repository in development, you would run following command:



```

./npmw install --save-dev --save-exact @types/leaflet

```



Then you would import the JS and CSS files specified in library's installation instructions so that [Webpack][] knows about them:

Edit [src/main/webapp/app/app.config.ts](src/main/webapp/app/app.config.ts) file:



```

import 'leaflet/dist/leaflet.js';

```



Edit [src/main/webapp/content/scss/vendor.scss](src/main/webapp/content/scss/vendor.scss) file:



```

@import 'leaflet/dist/leaflet.css';

```



Note: There are still a few other things remaining to do for Leaflet that we won't detail here.



For further instructions on how to develop with JHipster, have a look at [Using JHipster in development][].



### Using Angular CLI



You can also use [Angular CLI][] to generate some custom client code.



For example, the following command:



```

ng generate component my-component

```



will generate few files:



```

create src/main/webapp/app/my-component/my-component.component.html

create src/main/webapp/app/my-component/my-component.component.ts

update src/main/webapp/app/app.config.ts

```



## Building for production



### Packaging as jar



To build the final jar and optimize the divineSign application for production, run:



```

./mvnw -Pprod clean verify -DskipTests

```



This will concatenate and minify the client CSS and JavaScript files. It will also modify `index.html` so it references these new files.

To ensure everything worked, run:



```

java -jar target/*.jar

```



Then navigate to [http://localhost:8080](http://localhost:8080) in your browser.



Refer to [Using JHipster in production][] for more details.



### Packaging as war



To package your application as a war in order to deploy it to an application server, run:



```

./mvnw -Pprod,war clean verify

```



### JHipster Control Center



JHipster Control Center can help you manage and control your application(s). You can start a local control center server (accessible on http://localhost:7419) with:



```

docker compose -f src/main/docker/jhipster-control-center.yml up

```



## Testing



### Spring Boot tests



To launch your application's tests, run:



```

./mvnw verify

```



### Client tests



Unit tests are run by [Jest][]. They're located in [src/test/javascript/](src/test/javascript/) and can be run with:



```

./npmw test

```



## Others



### Code quality using Sonar



Sonar is used to analyse code quality. You can start a local Sonar server (accessible on http://localhost:9001) with:



```

docker compose -f src/main/docker/sonar.yml up -d

```



Note: we have turned off forced authentication redirect for UI in [src/main/docker/sonar.yml](src/main/docker/sonar.yml) for out of the box experience while trying out SonarQube, for real use cases turn it back on.



You can run a Sonar analysis with using the [sonar-scanner](https://docs.sonarqube.org/display/SCAN/Analyzing+with+SonarQube+Scanner) or by using the maven plugin.



Then, run a Sonar analysis:



```

./mvnw -Pprod clean verify sonar:sonar -Dsonar.login=admin -Dsonar.password=admin

```



If you need to re-run the Sonar phase, please be sure to specify at least the `initialize` phase since Sonar properties are loaded from the sonar-project.properties file.



```

./mvnw initialize sonar:sonar -Dsonar.login=admin -Dsonar.password=admin

```



Additionally, Instead of passing `sonar.password` and `sonar.login` as CLI arguments, these parameters can be configured from [sonar-project.properties](sonar-project.properties) as shown below:



```

sonar.login=admin

sonar.password=admin

```



For more information, refer to the [Code quality page][].



### Using Docker to simplify development (optional)



You can use Docker to improve your JHipster development experience. A number of docker-compose configuration are available in the [src/main/docker](src/main/docker) folder to launch required third party services.



For example, to start a database in a docker container, run:



```

docker compose -f src/main/docker/mongodb.yml up -d

```



To stop it and remove the container, run:



```

docker compose -f src/main/docker/mongodb.yml down

```



You can also fully dockerize your application and all the services that it depends on.

To achieve this, first build a docker image of your app by running:



```

npm run java:docker

```



Or build a arm64 docker image when using an arm64 processor os like MacOS with M1 processor family running:



```

npm run java:docker:arm64

```



Then run:



```

docker compose -f src/main/docker/app.yml up -d

```



When running Docker Desktop on MacOS Big Sur or later, consider enabling experimental `Use the new Virtualization framework` for better processing performance ([disk access performance is worse](https://github.com/docker/roadmap/issues/7)).



For more information refer to [Using Docker and Docker-Compose][], this page also contains information on the docker-compose sub-generator (`jhipster docker-compose`), which is able to generate docker configurations for one or several JHipster applications.



## Continuous Integration (optional)



To configure CI for your project, run the ci-cd sub-generator (`jhipster ci-cd`), this will let you generate configuration files for a number of Continuous Integration systems. Consult the [Setting up Continuous Integration][] page for more information.



[JHipster Homepage and latest documentation]: https://www.jhipster.tech

[JHipster 8.7.1 archive]: https://www.jhipster.tech/documentation-archive/v8.7.1

[Using JHipster in development]: https://www.jhipster.tech/documentation-archive/v8.7.1/development/

[Using Docker and Docker-Compose]: https://www.jhipster.tech/documentation-archive/v8.7.1/docker-compose

[Using JHipster in production]: https://www.jhipster.tech/documentation-archive/v8.7.1/production/

[Running tests page]: https://www.jhipster.tech/documentation-archive/v8.7.1/running-tests/

[Code quality page]: https://www.jhipster.tech/documentation-archive/v8.7.1/code-quality/

[Setting up Continuous Integration]: https://www.jhipster.tech/documentation-archive/v8.7.1/setting-up-ci/

[Node.js]: https://nodejs.org/

[NPM]: https://www.npmjs.com/

[OpenAPI-Generator]: https://openapi-generator.tech

[Swagger-Editor]: https://editor.swagger.io

[Doing API-First development]: https://www.jhipster.tech/documentation-archive/v8.7.1/doing-api-first-development/

[Webpack]: https://webpack.github.io/

[BrowserSync]: https://www.browsersync.io/

[Jest]: https://facebook.github.io/jest/

[Leaflet]: https://leafletjs.com/

[DefinitelyTyped]: https://definitelytyped.org/

[Angular CLI]: https://cli.angular.io/