With this commit http.new_request want an enum instead of a string. But Gitly want a string as method argument.

You need to replace the line 50 of oauth.v from :

	mut request := http.new_request('get', 'https://api.github.com/user', '') or {

to :

	mut request := http.new_request(http.Method.get, 'https://api.github.com/user', '') or {

Here the build logs :

Cloning into '/opt/gitly'...
./oauth.v:50:22: error: cannot use type `string` as type `net.http.Method` in argument 1 to `net.http.new_request` 
   48 |     }
   49 |     mut token := resp.text.find_between('access_token=', '&')
   50 |     mut request := http.new_request('get', 'https://api.github.com/user', '') or {
      |                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   51 |         app.info(err)
   52 |         return app.r_home()
The command '/bin/sh -c  v .' returned a non-zero code: 1

<form action="/Surman/libtccv" method="delete">
		<input type="text" name="verify" placeholder="Type your repo path username/reponame" required="">
		<input type="submit" value="Delete repo">
</form>

Is invalid as DELETE is not a valid method for html forms. Invalid values for the method result in GET. Thus it can't work.

But such repository cannot be opened and no link is visible in repository list.
I have reproduced the issue on gitly.org when logged in as medvednikov user.

I hope gitly can support Chinese.

You can see private repositories, when you guess the path of the repository. Example:
https://gitly.org/Fumeaux/clithing

Something a la GitLab that could be cool to have a quick grasp at the file types in a repository folder.

Hello.

I would like to know something technical: plugin licensing, gitly add-on. If the gitly platform is gplv3 licensed, if I create an add-on or plugin on gitly. Do I have to include gplv3 licensing also in the addon and plugin?

Hello, I recently tried Gitly and it looks very nice. However, it seems that markdown is not supported in Gitly recently. Gitly will be much nicer if markdown is supported in GitLy, especially for the README.md file. Thanks.

The 'alex/v' repo does not actually have issues, but https://gitly.org/alex/v/issue/1 shows the first ever created issue, which belongs to some other repo.
There is a related problem, that one can see issues of private repositories that way too.

There are several command injection vulnerabilities in Gitly:

I think there are more possible injection points so it is probably not enough to fix these parts only.

If possible, consider Adding a security policy to your repository in the future.

The url https://gitly.org is showing invalid SSL certificate error.

We should add an ability to use s3 for file storage rather than local storage if the user wants. This will allow both horizontal scaling as well as hosting on small servers like fly.io.
Since already RAM requirements are very less.

Steps to reproduce issue:

1. Head to http://gitly.org/
2. Click on sign in on top left trainer
3. Click on Login via GitHub
4. github returns 404.

All issues seem to increment a global issue counter and not a distinct counter per repo. When creating the first issue in a new repository, the counter does not start at '1', but rather at the number-of-all-issues + 1.

go here:
http://gitly.org/medvednikov/v/blob/master/examples/process/execve.v
and click on "examples", you get here
http://gitly.org/medvednikov/v/tree//examples
which is an invalid link, we get 404 Not Found

Hi everyone.

I was trying to use gitly in codespaces and got this error.

src/gitly.v:234:1: notice: generic method routes of vweb will be skipped
  232 | }
  233 | 
  234 | fn (mut app App) json_success[T](result T) vweb.Result {
      | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  235 |     response := api.ApiSuccessResponse[T]{
  236 |         success: true
src/gitly.v:234:1: notice: generic method routes of vweb will be skipped
  232 | }
  233 | 
  234 | fn (mut app App) json_success[T](result T) vweb.Result {
      | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  235 |     response := api.ApiSuccessResponse[T]{
  236 |         success: true
src/gitly.v:234:1: notice: generic method routes of vweb will be skipped
  232 | }
  233 | 
  234 | fn (mut app App) json_success[T](result T) vweb.Result {
      | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  235 |     response := api.ApiSuccessResponse[T]{
  236 |         success: true

Hi everyone.

I have great idea... what do you all think of the idea of ​​having a calendar in the gitly sidebar to search for pull requests and made commits?

Idea

I would like to know what you all think of this idea. What you all think of this idea?

I just wanted to know how and where are you handling the sending of mail and if you are using the net.smtp package.
Thank you.

You can view repositories that are private even if you are not logged in. Even better, private repositories are displayed on a users profile. I've only tried this on my own account so far, but with different devices and browsers.

For a fair comparison on http://gitly.org/ you may want to compare to gitea made in golang.
https://github.com/go-gitea/gitea

With that I mean, supporting things like the git-bug issue storage format, which stores issues inside the git repo, instead (or at least alternative to) storing them in a database.
The general idea is, to have projects entirely self-contained within their repo, and thus be truly independent of the platform they are hosted on. In reality today, this is only true for the source code. the whole rest - roughtly "the community" part - is not distributed. This would be a killer feature!

Hi everyone.

Idea

tasks, messages, events, file, activities

another idea

image-description: I was thinking of adding these features in git: kanban, to do list for managing issues.

another idea

Concept

Change profile

Add bio, twitter username, mastodon username, Peertube username, website url, company url ...

feedback/question

I would like to know what you all think of this idea. What you all think of this idea?

Gitly CI/CD design

Hi, I'm here to talk about CI/CD integration for Gitly.

I use daily CI/CD on both GitLab and GitHub, and I see the power of the both technology.

GitLab has highly customisable and powerful pipelines. It also has parallels runs.

GitHub as simple workflow and highly community oriented workflow.

So I try to keep the powerful GitLab pipelines with the comminuty based workflow of GitHub Actions.

I think It's powerful enough to do anything.

Here my proposal of a YAML for Gitly CI/CD file.

# filename -> .gitly/flow/

# Name of the flow pipeline
name: Build MyApp

# Define the differents steps of the pipeline flow.
## Steps are launched in the order of the list.
## Names can be customized by developer.
steps:
  - prepare
  - build
  - test
  - publish

# Define each jobs run by the flow
jobs:
  # Set the id of the job to be selected after.
  docker-prepare:
    # Set the display name of the jobs. (default will be the id)
    name: Prepare the Docker environment
    # Set the contraints of the job
    on:
      # Link this job into the `prepare` steps.
      ## This will display it in the first column of the flow view. (because prepare is the first)
      steps:
      - prepare
      # run this job only on push event.
      events:
      - push
      # Run this jobs only on event triggered on `main` and `staging` branch...
      branches:
      - main
      - staging
      # ...or Run it on tags like `v1.0`
      tags:
      - v(.*)
    # Define all actions that job will run.
    actions:
      # Get the source code of the repository.
      - name: Checkout
         ## This can be the same like this : gitly.org/gitly/flow/checkout@master
         ## We can use @<branch_name> or @<tag_name>. 
         ## Any @<tag_name> must be cached to not recompile it at any use.
         ## So using @<tag_name> will speedup your flow.
         use: checkout@v1
         args:
           # (Optional)
           ref: ${gitly.event.ref}
      # define another action that run a user custom flow by selecting his public repository. (Can be on other git server)
      - name: Get environment docker image
         use: gitly.org/newuser/myflow-pull.git@master
      # define another action that run a user custom flow by selecting his public repository. (Can be on other git server)
      - name: Publish Environment Docker image
         use: gitly.org/newuser/myflow-push.git@master
         args:
           repo: ${gitly.server.docker_repository}
           tag: ${gitly.repository.url}/android:${gitly.event.branch-or-tag}
       - name: Display image size
         # This `use` is optional, it allow to choose a prefered runner and/or a docker image.
         use: ubuntu
         scripts:
         # Ouput is defined by the flow repository (Here by gitly.org/newuser/myflow-push.git@master)
         - echo "${gitly.jobs.docker-prepare.output.docker_image_size}"

  # Run another job (Other job will not contain the same folder, but can get it from )
  display-env:
    on:
      steps:
      - prepare
      # Without this, jobs are in parallels. You can access to output of jobs only if his id are listed here.
      after:
      - docker-prepare
    actions:
      - name: Display android sdkmanager version
         # This use docker image
         use: ${gitly.server.docker_repository}/${gitly.repository.url}
         scripts:
         - sdkmanager --version

  display-env:
    on:
      steps:
      - prepare
    actions:
      - name: Display flutter version
         # This use docker image
         use: ${gitly.server.docker_repository}/${gitly.repository.url}
         scripts:
         - flutter --version

  build_job:
    # Link to docker-prepare to get output
    ## But I didn't define any steps, so it will not be runned.
    ## That allow to use it as template and shortcut other actions or jobs.
    on:
      after:
      - docker-prepare
    actions:
    - id: build-setup
      use: ${gitly.server.docker_repository}/${gitly.repository.url}
      before_script:
      - echo "${gitly.secrets.signing_jks_file_hex}" | xxd -r -p - > android-signing-keystore.jks
      - "export VERSION_CODE=${gitly.flow.id} && echo $VERSION_CODE"
      - "export VERSION_SHA=`echo ${gitly.event.commit_sha:0:8}` && echo $VERSION_SHA"
      - cp ./fastlane/metadata/android/en-GB/changelogs/CURRENT_VERSION.txt "./fastlane/metadata/android/en-GB/changelogs/$VERSION_CODE.txt"
      - chmod +x ./fastlane/create-changelog-mr.sh
      - ./fastlane/create-changelog-mr.sh || true
      - git checkout "${gitly.event.commit_sha}"
      after_script:
      - rm -f android-signing-keystore.jks || true
    - id: upload-artifact
      name: Upload Artifact
      use: set_artifact@v1
      args:
        id: app_bundle
        name: App Bundle
        paths: app/build/outputs

# Run job in build steps
  build-debug:
    on:
      steps:
      - build
    actions:
      - name: Checkout
         use: checkout@v1
      # This extends will keep everything in the actions build_job.build-setup (scripts, before-scripts, after-scripts, env, ...) 
      ## But you can append those elements here.
      ## If you fix an id on the action, you can replace the action by re-set it here with the fixed id too.
      - extends: build_job.build-setup
         name: Build debug
         # This use docker image
         use: ${gitly.server.docker_repository}/${gitly.repository.url}
         scripts:
         - bundle exec fastlane buildDebug

  build-release:
    on:
      steps:
      - build
    actions:
      - name: Checkout
         use: checkout@v1
      # Like you can see, when you use a docker image, the current workspace will be copied into the image.
      ## So if you use checkout here, the docker image will get the repository.
      - extends: build_job.build-setup
         name: Build release
         use: ${gitly.server.docker_repository}/${gitly.repository.url}
         scripts:
         - bundle exec fastlane buildRelease

  test-debug:
    on:
      after: 
      - build-debug
      steps:
      - test
    actions:
      - name: Checkout
         use: checkout@v1
      - name: Test Debug
         use: ${gitly.server.docker_repository}/${gitly.repository.url}
         scripts:
         - bundle exec fastlane testDebug

  test-release:
    on:
      after: 
      - build-release
      steps:
      - test
    actions:
      - name: Checkout
         use: checkout@v1
      - name: Test Release
         use: ${gitly.server.docker_repository}/${gitly.repository.url}
         scripts:
         - bundle exec fastlane testDebug

  publish-internal:
    on:
      after: 
      # Here it will wait for test to finish, because it run on steps publish, and all `publish` steps will always be run after `test` steps
      - build-debug
      steps:
      - publish
    actions:
      - name: Downlaod Artifact
         use: get_artifact@v1
         args:
           artifact: ${gitly.jobs.build-release.output.app_bundle.artifact_url}
           path: app/build/outputs
      - name: Publish to Playstore in Internal
         use: ${gitly.server.docker_repository}/${gitly.repository.url}
         scripts:
         - bundle exec fastlane internal

It allow to get a Flow like the GitLab Pipelines with the power of Actions like GitHub Action.

It's in the name. There is no warning, but the repositories aren't really seperate either. Creating a repository from a GitHub repo, with an already existing name apparently causes the clone process to fail. Commits are still displayed properly, but files aren't.
Attached are some images detailing how it exactly looks like.

When I try to clone and build gitly on Alpine Linux 3.18 using v version: V 0.4.0 3c26bff, I get errors:
F.e.:

/src/feed_service.v:14:23: error: exec() returns a Result, so it should have either an `or {}` block, or `!` at the end
   12 |     where_repo_ids := repo_ids.map(it.str()).join(', ')
   13 |
   14 |     commits, _ := app.db.exec('
      |                          ~~~~~~
   15 |         select author, hash, created_at, repo_id, branch_id, message from `Commit`
   16 |             where repo_id in (${where_repo_ids}) order by created_at desc
/src/feed_service.v:20:16: error: invalid variable `commits`
   18 |     mut item_id := 0
   19 |
   20 |     for commit in commits {
      |                   ~~~~~~~
   21 |         vals := commit.vals
   22 |         author_name := vals[0]
/src/feed_service.v:21:18: error: `commit` does not return a value
   19 |
   20 |     for commit in commits {
   21 |         vals := commit.vals
      |                        ~~~~
   22 |         author_name := vals[0]
   23 |         commit_hash := vals[1]

etc
Compiler used on Alpine Linux: -cc gcc

At the same time, on Windows 10 the same repository builds successfully using v version: V 0.4.0 320057d and tcc compiler.

Probably compiler (gcc vs tcc) is the errors' cause?

I'm not an expert in C compilers etc, so I may be wrong.

Appreciate any help!

The writing of yaml is cumbersome and prone to errors, and it would be great if gitea could be configured in a UI capable manner.

The following are relevant tools that can be referenced:

https://github.com/milanm/DevOps-Roadmap

Hi everyone.

I want to help, but I want to know if this project is active. Is this project active?

Currently you can only authorize on gitly if your GitHub profile has public email.

Steps to reproduce:

1. Open your GitHub profile settings by clicking Settings menu in profile.
2. Open "Profile" tab
3. Choose "Select a verified email to display" in select labelled as "Public email"
   
4. Try to authorize on gitly.org

Expected results:
You should authorize and your account name should be displayed in header.

Actual results:
Gitly just redirects you on index page, no account name displayed.

If you try to repeat all the steps above, but select your email instead:

In this case authorization is successful.

Possible solution
You should try to identify users with unique user id github API provides, not email, if this is possible.

Note
You can check if user has public email by visiting its profile page on GitHub. For users with public email it is displayed there.

I found this out while building my own vweb server, by mistake, and wondered if gitly has the same issue.

By loading https://gitly.org//, the site fails to work correctly

In my own instance, the error I get is

[vweb] tid: 000, error parsing path: net.urllib.parse: failed parsing url

and the Firefox says "The connection was reset"

I don't know if this is the same case.

Uptime shown in admin interface is completely wrong, for example:

(you can also see here that auth issue mentioned in #150 is not fixed)

I believe it has something to do with the following code:

pub fn (mut app App) running_since() string {
	dur := time.now().unix - app.started_at
	seconds := dur % 60
	minutes := int(math.floor(dur / 60)) % 60
	hours := int(math.floor(minutes / 60)) % 24
	days := int(math.floor(hours / 24))
	return '$days days $hours hours $minutes minutes and $seconds seconds'
}

Taking into account that app.started_at was always zero whenever I checked, it should show a really enormous uptime, but in fact it always shows that Gitly is up for less than a hour.

Hi everyone.

concept

I think in addition to adding a p2p storage, having the option to migrate the code to github/gitlab/bitbucket and more platforms. That way we can have an interoperability, backup. So that if one of these platforms stops working, another one won't.

I use a tool called git-bug which is close to the idea of ​​a protocol like email/matrix. I mean, the issues are distributed on different platforms. I think about integrating the idea of ​​gitbug into gitly, in addition to p2p storage.

In other words, having an option to migrate code for backup or mirroring. Just like, also storage is an interesting idea. There are tools for example non-hosted that work with protocols like remote storage or local storage in the browser like cookies, local storage. These tools are self-hosted, they usually have some p2p protocol as well.

question/feedback

I would like to know what the community thinks about this idea.

Reference

• #135

The content of the files is 404 on the v repo as of now

steps to reproduce:

1. go to http://gitly.org/medvednikov/v/blob/master/tutorials/building_a_simple_web_blog_with_vweb/code/blog/blog.v
2. click the tutorials hyperlink above the text
3. see the 404

Hi everyone.

Idea

An interesting idea would be for the community to provide an open core plan, part of the open code and support is paid, this to enable more features, developers, etc.

Concept

https://about.gitly.com/pricing/

Image

reference

• #142

question/feedback

What do you all think of this idea?

Hi all.

I was trying to use gitly in codespaces and got this error.

src/gitly.v:234:1: notice: generic method routes of vweb will be skipped
  232 | }
  233 | 
  234 | fn (mut app App) json_success[T](result T) vweb.Result {
      | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  235 |     response := api.ApiSuccessResponse[T]{
  236 |         success: true
src/gitly.v:234:1: notice: generic method routes of vweb will be skipped
  232 | }
  233 | 
  234 | fn (mut app App) json_success[T](result T) vweb.Result {
      | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  235 |     response := api.ApiSuccessResponse[T]{
  236 |         success: true
src/gitly.v:234:1: notice: generic method routes of vweb will be skipped
  232 | }
  233 | 
  234 | fn (mut app App) json_success[T](result T) vweb.Result {
      | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  235 |     response := api.ApiSuccessResponse[T]{
  236 |         success: true
@codehangen ➜ /workspaces/vlang/v/gitly (master) $ 

Cloudflare reports an invalid SSL certificate.

Orgmode is similar to markdown, with it being plain text and not too much of a hassle to parse.

Orgmode
Orgmode guide

org files as readmes and documentation aren't nearly as common as markdown, orgmode can also export to markdown and Github specific markdown.
example file

*I'll update the above example to be more complete/informative at a later date

Details:

Running a Vweb app on http://localhost:8080
[INFO  2021-02-07 01:51:47] init_once()
/tmp/v/gitly.9883544477089273822.tmp.c:19088: at net__TcpConn_write_ptr: RUNTIME ERROR: invalid memory access
/tmp/v/gitly.9883544477089273822.tmp.c:19118: by net__TcpConn_write
/tmp/v/gitly.9883544477089273822.tmp.c:43598: by vweb__send_string
/tmp/v/gitly.9883544477089273822.tmp.c:21728: by vweb__Context_send_response_to_client
/tmp/v/gitly.9883544477089273822.tmp.c:21759: by vweb__Context_text
/tmp/v/gitly.9883544477089273822.tmp.c:45940: by main__App_info
/tmp/v/gitly.9883544477089273822.tmp.c:45964: by main__App_init_once
/tmp/v/gitly.9883544477089273822.tmp.c:21938: by vweb__run_app_T_main__App
/tmp/v/gitly.9883544477089273822.tmp.c:21925: by vweb__run_T_main__App
/tmp/v/gitly.9883544477089273822.tmp.c:45934: by main__main
/tmp/v/gitly.9883544477089273822.tmp.c:51837: by main
charles@charles-pad:~/gitly$ 

It would be a killer feature to have live examples of V repositories embedded straight in the README.md.

The V compiler can run in WASM - so if you can have live examples of V UI, sokol and other kinds of module code it would be a bad ass thing to have - instead of GIFs, have live examples.

This error happened during the building service.

gitly git:(master) v run .
src/repo.v:28:53: error: unexpected token @, expecting name
26 | latest_activity time.Time @[skip]
27 | mut:
28 | git_repo &git.Repo = unsafe { nil } @[skip] // libgit wrapper repo
| ^
29 | webhook_secret string
30 | tags_count int

It would be nice to be able to discuss a change (like on Github) and a line (in the code viewer, by simply having some button like "Start discussion" at the side).

In the latter case, it would be nice to notify (via email or alike) the user who wrote the code in the first place (say à la "git blame") via email for instance.

The discussion thread could be shown at the side of the code (at the left) and hidden by default, showing only a small icon or someway highlighting the affected LoC

When I was trying to login with GitHub oAuth, its showing me 404 page

You can insert Javascript into a README.md that is executed without sanitation. This could be used to hijack a users browser, to mine crypto currency, feed a Botnet, e.g. to artificially increase a Users follower count on social media or to feed into a DDoS attack, even stealing bank information is possible.
A working POC is available at Not-Nik/lo3. The XSS is so basic in fact that a README.md of just

<script>
// Your arbitrary code here
</script>

is possible.

https://gitly.org/alex/vlang