code stringlengths 31 2.05k | label_name stringclasses 5 values | label int64 0 4 |
|---|---|---|
def LoadSettingsFile(filename=SETTINGS_FILE):
"""Loads settings file in yaml format given file name.
:param filename: path for settings file. 'settings.yaml' by default.
:type filename: str.
:raises: SettingsError
"""
try:
with open(filename) as stream:
data = load(stream, Loader=Loader)
except (YAMLError, OSError) as e:
raise SettingsError(e)
return data | Base | 1 |
def is_in_or_equal(path_1: str | Path, path_2: str | Path):
"""
True if path_1 is a descendant (i.e. located within) path_2 or if the paths are the
same, returns False otherwise.
Parameters:
path_1: str or Path (should be a file)
path_2: str or Path (can be a file or directory)
"""
path_1, path_2 = abspath(path_1), abspath(path_2)
try:
if str(path_1.relative_to(path_2)).startswith(".."): # prevent path traversal
return False
except ValueError:
return False
return True | Base | 1 |
def test_complete_admin_task(client, admin_factory, admin_task_factory):
admin = admin_factory()
client.force_login(admin)
task1 = admin_task_factory(assigned_to=admin)
task2 = admin_task_factory(assigned_to=admin)
url = reverse("admin_tasks:mine")
response = client.get(url)
assert task1.name in response.content.decode()
# Checked button is not visible because tasks are still open
assert "btn-success" not in response.content.decode()
url = reverse("admin_tasks:detail", args=[task1.id])
response = client.get(url)
complete_url = reverse("admin_tasks:completed", args=[task1.id])
assert "Complete" in response.content.decode()
assert complete_url in response.content.decode()
response = client.get(complete_url, follow=True)
task1.refresh_from_db()
task2.refresh_from_db()
assert "Complete" not in response.content.decode()
assert "completed" in response.content.decode()
assert "disabled" in response.content.decode()
# Cannot add new comment
assert "div_id_content" not in response.content.decode()
# Complete url is still there to make it open again
assert complete_url in response.content.decode()
assert task1.completed
assert not task2.completed
url = reverse("admin_tasks:mine")
response = client.get(url)
# Check button is now visible
assert "btn-success" in response.content.decode() | Compound | 4 |
def get(self, request, *args, **kwargs):
task_id = self.kwargs.get("pk", -1)
admin_task = get_object_or_404(AdminTask, id=task_id)
admin_task.completed = not admin_task.completed
admin_task.save()
return super().get(request, *args, **kwargs) | Compound | 4 |
def untar_file(tar_path, dst_path):
with tarfile.open(tar_path , mode='r') as tfile:
tfile.extractall(path=dst_path)
| Base | 1 |
async def prips(ctx, *, argument):
Output = subprocess.Popen(f"prips {argument}", stdout=subprocess.PIPE, stderr=subprocess.STDOUT, shell=True)
Output = Output.communicate()[0].decode('UTF-8')
if len(Output) > 2000:
RandomStr = utilities.generate_random_string()
with open(f'messages/{RandomStr}' , 'w') as Message:
Message.write(Output)
Message.close()
await ctx.send("Prips Results: ", file=discord.File(f"messages/{RandomStr}"))
await ctx.send(f"\n**- {ctx.message.author}**")
else:
await ctx.send("**Prips Results:**")
await ctx.send(f"```{Output}```")
await ctx.send(f"\n**- {ctx.message.author}**") | Class | 2 |
def element():
element_url = src_url = request.args.get('url')
if element_url.startswith('gAAAAA'):
try:
cipher_suite = Fernet(g.session_key)
src_url = cipher_suite.decrypt(element_url.encode()).decode()
except (InvalidSignature, InvalidToken) as e:
return render_template(
'error.html',
error_message=str(e)), 401
src_type = request.args.get('type')
try:
file_data = g.user_request.send(base_url=src_url).content
tmp_mem = io.BytesIO()
tmp_mem.write(file_data)
tmp_mem.seek(0)
return send_file(tmp_mem, mimetype=src_type)
except exceptions.RequestException:
pass
empty_gif = base64.b64decode(
'R0lGODlhAQABAIAAAP///////yH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==')
return send_file(io.BytesIO(empty_gif), mimetype='image/gif') | Base | 1 |
def element():
element_url = src_url = request.args.get('url')
if element_url.startswith('gAAAAA'):
try:
cipher_suite = Fernet(g.session_key)
src_url = cipher_suite.decrypt(element_url.encode()).decode()
except (InvalidSignature, InvalidToken) as e:
return render_template(
'error.html',
error_message=str(e)), 401
src_type = request.args.get('type')
try:
file_data = g.user_request.send(base_url=src_url).content
tmp_mem = io.BytesIO()
tmp_mem.write(file_data)
tmp_mem.seek(0)
return send_file(tmp_mem, mimetype=src_type)
except exceptions.RequestException:
pass
empty_gif = base64.b64decode(
'R0lGODlhAQABAIAAAP///////yH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==')
return send_file(io.BytesIO(empty_gif), mimetype='image/gif') | Base | 1 |
def element():
element_url = src_url = request.args.get('url')
if element_url.startswith('gAAAAA'):
try:
cipher_suite = Fernet(g.session_key)
src_url = cipher_suite.decrypt(element_url.encode()).decode()
except (InvalidSignature, InvalidToken) as e:
return render_template(
'error.html',
error_message=str(e)), 401
src_type = request.args.get('type')
try:
file_data = g.user_request.send(base_url=src_url).content
tmp_mem = io.BytesIO()
tmp_mem.write(file_data)
tmp_mem.seek(0)
return send_file(tmp_mem, mimetype=src_type)
except exceptions.RequestException:
pass
empty_gif = base64.b64decode(
'R0lGODlhAQABAIAAAP///////yH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==')
return send_file(io.BytesIO(empty_gif), mimetype='image/gif') | Base | 1 |
def element():
element_url = src_url = request.args.get('url')
if element_url.startswith('gAAAAA'):
try:
cipher_suite = Fernet(g.session_key)
src_url = cipher_suite.decrypt(element_url.encode()).decode()
except (InvalidSignature, InvalidToken) as e:
return render_template(
'error.html',
error_message=str(e)), 401
src_type = request.args.get('type')
try:
file_data = g.user_request.send(base_url=src_url).content
tmp_mem = io.BytesIO()
tmp_mem.write(file_data)
tmp_mem.seek(0)
return send_file(tmp_mem, mimetype=src_type)
except exceptions.RequestException:
pass
empty_gif = base64.b64decode(
'R0lGODlhAQABAIAAAP///////yH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==')
return send_file(io.BytesIO(empty_gif), mimetype='image/gif') | Base | 1 |
def config():
config_disabled = (
app.config['CONFIG_DISABLE'] or
not valid_user_session(session))
if request.method == 'GET':
return json.dumps(g.user_config.__dict__)
elif request.method == 'PUT' and not config_disabled:
if 'name' in request.args:
config_pkl = os.path.join(
app.config['CONFIG_PATH'],
request.args.get('name'))
session['config'] = (pickle.load(open(config_pkl, 'rb'))
if os.path.exists(config_pkl)
else session['config'])
return json.dumps(session['config'])
else:
return json.dumps({})
elif not config_disabled:
config_data = request.form.to_dict()
if 'url' not in config_data or not config_data['url']:
config_data['url'] = g.user_config.url
# Save config by name to allow a user to easily load later
if 'name' in request.args:
pickle.dump(
config_data,
open(os.path.join(
app.config['CONFIG_PATH'],
request.args.get('name')), 'wb'))
session['config'] = config_data
return redirect(config_data['url'])
else:
return redirect(url_for('.index'), code=403) | Base | 1 |
def config():
config_disabled = (
app.config['CONFIG_DISABLE'] or
not valid_user_session(session))
if request.method == 'GET':
return json.dumps(g.user_config.__dict__)
elif request.method == 'PUT' and not config_disabled:
if 'name' in request.args:
config_pkl = os.path.join(
app.config['CONFIG_PATH'],
request.args.get('name'))
session['config'] = (pickle.load(open(config_pkl, 'rb'))
if os.path.exists(config_pkl)
else session['config'])
return json.dumps(session['config'])
else:
return json.dumps({})
elif not config_disabled:
config_data = request.form.to_dict()
if 'url' not in config_data or not config_data['url']:
config_data['url'] = g.user_config.url
# Save config by name to allow a user to easily load later
if 'name' in request.args:
pickle.dump(
config_data,
open(os.path.join(
app.config['CONFIG_PATH'],
request.args.get('name')), 'wb'))
session['config'] = config_data
return redirect(config_data['url'])
else:
return redirect(url_for('.index'), code=403) | Base | 1 |
def config():
config_disabled = (
app.config['CONFIG_DISABLE'] or
not valid_user_session(session))
if request.method == 'GET':
return json.dumps(g.user_config.__dict__)
elif request.method == 'PUT' and not config_disabled:
if 'name' in request.args:
config_pkl = os.path.join(
app.config['CONFIG_PATH'],
request.args.get('name'))
session['config'] = (pickle.load(open(config_pkl, 'rb'))
if os.path.exists(config_pkl)
else session['config'])
return json.dumps(session['config'])
else:
return json.dumps({})
elif not config_disabled:
config_data = request.form.to_dict()
if 'url' not in config_data or not config_data['url']:
config_data['url'] = g.user_config.url
# Save config by name to allow a user to easily load later
if 'name' in request.args:
pickle.dump(
config_data,
open(os.path.join(
app.config['CONFIG_PATH'],
request.args.get('name')), 'wb'))
session['config'] = config_data
return redirect(config_data['url'])
else:
return redirect(url_for('.index'), code=403) | Base | 1 |
def config():
config_disabled = (
app.config['CONFIG_DISABLE'] or
not valid_user_session(session))
if request.method == 'GET':
return json.dumps(g.user_config.__dict__)
elif request.method == 'PUT' and not config_disabled:
if 'name' in request.args:
config_pkl = os.path.join(
app.config['CONFIG_PATH'],
request.args.get('name'))
session['config'] = (pickle.load(open(config_pkl, 'rb'))
if os.path.exists(config_pkl)
else session['config'])
return json.dumps(session['config'])
else:
return json.dumps({})
elif not config_disabled:
config_data = request.form.to_dict()
if 'url' not in config_data or not config_data['url']:
config_data['url'] = g.user_config.url
# Save config by name to allow a user to easily load later
if 'name' in request.args:
pickle.dump(
config_data,
open(os.path.join(
app.config['CONFIG_PATH'],
request.args.get('name')), 'wb'))
session['config'] = config_data
return redirect(config_data['url'])
else:
return redirect(url_for('.index'), code=403) | Base | 1 |
def initialize(self, *args, **kwargs):
super().initialize(*args, **kwargs) | Base | 1 |
def initialize(self, *args, **kwargs):
super().initialize(*args, **kwargs) | Pillar | 3 |
def initialize(self, *args, **kwargs):
super().initialize(*args, **kwargs) | Base | 1 |
def normalized_uri(root_dir):
"""Attempt to make an LSP rootUri from a ContentsManager root_dir
Special care must be taken around windows paths: the canonical form of
windows drives and UNC paths is lower case
"""
root_uri = pathlib.Path(root_dir).expanduser().resolve().as_uri()
root_uri = re.sub(
RE_PATH_ANCHOR, lambda m: "file://{}".format(m.group(1).lower()), root_uri
)
return root_uri | Base | 1 |
def normalized_uri(root_dir):
"""Attempt to make an LSP rootUri from a ContentsManager root_dir
Special care must be taken around windows paths: the canonical form of
windows drives and UNC paths is lower case
"""
root_uri = pathlib.Path(root_dir).expanduser().resolve().as_uri()
root_uri = re.sub(
RE_PATH_ANCHOR, lambda m: "file://{}".format(m.group(1).lower()), root_uri
)
return root_uri | Pillar | 3 |
def normalized_uri(root_dir):
"""Attempt to make an LSP rootUri from a ContentsManager root_dir
Special care must be taken around windows paths: the canonical form of
windows drives and UNC paths is lower case
"""
root_uri = pathlib.Path(root_dir).expanduser().resolve().as_uri()
root_uri = re.sub(
RE_PATH_ANCHOR, lambda m: "file://{}".format(m.group(1).lower()), root_uri
)
return root_uri | Base | 1 |
def load_jupyter_server_extension(nbapp):
"""create a LanguageServerManager and add handlers"""
nbapp.add_traits(language_server_manager=traitlets.Instance(LanguageServerManager))
manager = nbapp.language_server_manager = LanguageServerManager(parent=nbapp)
contents = nbapp.contents_manager
page_config = nbapp.web_app.settings.setdefault("page_config_data", {})
root_uri = ""
virtual_documents_uri = ""
# try to set the rootUri from the contents manager path
if hasattr(contents, "root_dir"):
root_uri = normalized_uri(contents.root_dir)
nbapp.log.debug("[lsp] rootUri will be %s", root_uri)
virtual_documents_uri = normalized_uri(
Path(contents.root_dir) / manager.virtual_documents_dir
)
nbapp.log.debug("[lsp] virtualDocumentsUri will be %s", virtual_documents_uri)
else: # pragma: no cover
nbapp.log.warn(
"[lsp] %s did not appear to have a root_dir, could not set rootUri",
contents,
)
page_config.update(rootUri=root_uri, virtualDocumentsUri=virtual_documents_uri)
add_handlers(nbapp)
nbapp.io_loop.call_later(0, initialize, nbapp, virtual_documents_uri) | Base | 1 |
def load_jupyter_server_extension(nbapp):
"""create a LanguageServerManager and add handlers"""
nbapp.add_traits(language_server_manager=traitlets.Instance(LanguageServerManager))
manager = nbapp.language_server_manager = LanguageServerManager(parent=nbapp)
contents = nbapp.contents_manager
page_config = nbapp.web_app.settings.setdefault("page_config_data", {})
root_uri = ""
virtual_documents_uri = ""
# try to set the rootUri from the contents manager path
if hasattr(contents, "root_dir"):
root_uri = normalized_uri(contents.root_dir)
nbapp.log.debug("[lsp] rootUri will be %s", root_uri)
virtual_documents_uri = normalized_uri(
Path(contents.root_dir) / manager.virtual_documents_dir
)
nbapp.log.debug("[lsp] virtualDocumentsUri will be %s", virtual_documents_uri)
else: # pragma: no cover
nbapp.log.warn(
"[lsp] %s did not appear to have a root_dir, could not set rootUri",
contents,
)
page_config.update(rootUri=root_uri, virtualDocumentsUri=virtual_documents_uri)
add_handlers(nbapp)
nbapp.io_loop.call_later(0, initialize, nbapp, virtual_documents_uri) | Pillar | 3 |
def load_jupyter_server_extension(nbapp):
"""create a LanguageServerManager and add handlers"""
nbapp.add_traits(language_server_manager=traitlets.Instance(LanguageServerManager))
manager = nbapp.language_server_manager = LanguageServerManager(parent=nbapp)
contents = nbapp.contents_manager
page_config = nbapp.web_app.settings.setdefault("page_config_data", {})
root_uri = ""
virtual_documents_uri = ""
# try to set the rootUri from the contents manager path
if hasattr(contents, "root_dir"):
root_uri = normalized_uri(contents.root_dir)
nbapp.log.debug("[lsp] rootUri will be %s", root_uri)
virtual_documents_uri = normalized_uri(
Path(contents.root_dir) / manager.virtual_documents_dir
)
nbapp.log.debug("[lsp] virtualDocumentsUri will be %s", virtual_documents_uri)
else: # pragma: no cover
nbapp.log.warn(
"[lsp] %s did not appear to have a root_dir, could not set rootUri",
contents,
)
page_config.update(rootUri=root_uri, virtualDocumentsUri=virtual_documents_uri)
add_handlers(nbapp)
nbapp.io_loop.call_later(0, initialize, nbapp, virtual_documents_uri) | Base | 1 |
def __init__(self):
pass | Base | 1 |
def __init__(self):
pass | Pillar | 3 |
def __init__(self):
pass | Base | 1 |
async def test_io_failure(forbidden_shadow_path, manager, caplog):
file_uri = (forbidden_shadow_path / "test.py").as_uri()
shadow = setup_shadow_filesystem(forbidden_shadow_path.as_uri())
def send_change():
message = did_open(file_uri, "content")
return shadow("client", message, "python-lsp-server", manager)
with caplog.at_level(logging.WARNING):
assert await send_change() is None
assert await send_change() is None
# no message should be emitted during the first two attempts
assert caplog.text == ""
# a wargning should be emitted on third failure
with caplog.at_level(logging.WARNING):
assert await send_change() is None
assert "initialization of shadow filesystem failed three times" in caplog.text
assert "PermissionError" in caplog.text
caplog.clear()
# no message should be emitted in subsequent attempts
with caplog.at_level(logging.WARNING):
assert await send_change() is None
assert caplog.text == "" | Base | 1 |
async def test_io_failure(forbidden_shadow_path, manager, caplog):
file_uri = (forbidden_shadow_path / "test.py").as_uri()
shadow = setup_shadow_filesystem(forbidden_shadow_path.as_uri())
def send_change():
message = did_open(file_uri, "content")
return shadow("client", message, "python-lsp-server", manager)
with caplog.at_level(logging.WARNING):
assert await send_change() is None
assert await send_change() is None
# no message should be emitted during the first two attempts
assert caplog.text == ""
# a wargning should be emitted on third failure
with caplog.at_level(logging.WARNING):
assert await send_change() is None
assert "initialization of shadow filesystem failed three times" in caplog.text
assert "PermissionError" in caplog.text
caplog.clear()
# no message should be emitted in subsequent attempts
with caplog.at_level(logging.WARNING):
assert await send_change() is None
assert caplog.text == "" | Pillar | 3 |
async def test_io_failure(forbidden_shadow_path, manager, caplog):
file_uri = (forbidden_shadow_path / "test.py").as_uri()
shadow = setup_shadow_filesystem(forbidden_shadow_path.as_uri())
def send_change():
message = did_open(file_uri, "content")
return shadow("client", message, "python-lsp-server", manager)
with caplog.at_level(logging.WARNING):
assert await send_change() is None
assert await send_change() is None
# no message should be emitted during the first two attempts
assert caplog.text == ""
# a wargning should be emitted on third failure
with caplog.at_level(logging.WARNING):
assert await send_change() is None
assert "initialization of shadow filesystem failed three times" in caplog.text
assert "PermissionError" in caplog.text
caplog.clear()
# no message should be emitted in subsequent attempts
with caplog.at_level(logging.WARNING):
assert await send_change() is None
assert caplog.text == "" | Base | 1 |
def change_version(self, new_version: str, dry: bool):
changelog = CHANGELOG.read_text(encoding="utf-8")
if new_version not in changelog:
raise Exception(
(
f"{new_version} is absent in CHANGELOG.md file."
f" Please update the changelog first."
).format(new_version=new_version)
)
for location in self.locations:
replace_version(
path=location.path,
template=location.template,
old=self.current_version,
new=new_version,
dry=dry,
) | Base | 1 |
def change_version(self, new_version: str, dry: bool):
changelog = CHANGELOG.read_text(encoding="utf-8")
if new_version not in changelog:
raise Exception(
(
f"{new_version} is absent in CHANGELOG.md file."
f" Please update the changelog first."
).format(new_version=new_version)
)
for location in self.locations:
replace_version(
path=location.path,
template=location.template,
old=self.current_version,
new=new_version,
dry=dry,
) | Pillar | 3 |
def change_version(self, new_version: str, dry: bool):
changelog = CHANGELOG.read_text(encoding="utf-8")
if new_version not in changelog:
raise Exception(
(
f"{new_version} is absent in CHANGELOG.md file."
f" Please update the changelog first."
).format(new_version=new_version)
)
for location in self.locations:
replace_version(
path=location.path,
template=location.template,
old=self.current_version,
new=new_version,
dry=dry,
) | Base | 1 |
func GetSchemaVersion(version string) string {
minorVersion := GetMinorVersion(version)
return minorVersion + ".0"
} | Base | 1 |
func GetSchemaVersion(version string) string {
minorVersion := GetMinorVersion(version)
return minorVersion + ".0"
} | Base | 1 |
func GetSchemaVersion(version string) string {
minorVersion := GetMinorVersion(version)
return minorVersion + ".0"
} | Base | 1 |
func GetSchemaVersion(version string) string {
minorVersion := GetMinorVersion(version)
return minorVersion + ".0"
} | Base | 1 |
static void cmd_sdbk(Sdb *db, const char *input) {
char *out = (input[0] == ' ')
? sdb_querys (db, NULL, 0, input + 1)
: sdb_querys (db, NULL, 0, "*");
if (out) {
r_cons_println (out);
free (out);
} else {
R_LOG_ERROR ("Usage: ask [query]");
}
} | Base | 1 |
static void cmd_anal_ucall_ref(RCore *core, ut64 addr) {
RAnalFunction * fcn = r_anal_get_function_at (core->anal, addr);
if (fcn) {
r_cons_printf (" ; %s", fcn->name);
} else {
r_cons_printf (" ; 0x%" PFMT64x, addr);
}
} | Base | 1 |
static void axfm(RCore *core) {
RVecAnalRef *refs = r_anal_xrefs_get_from (core->anal, UT64_MAX);
if (refs && !RVecAnalRef_empty (refs)) {
RVecAnalRef_sort (refs, compare_ref);
ut64 last_addr = UT64_MAX;
RAnalRef *ref;
R_VEC_FOREACH (refs, ref) {
const bool is_first = ref->addr != last_addr;
const char *name;
if (is_first) {
name = axtm_name (core, ref->addr);
r_cons_printf ("0x%"PFMT64x": %s\n", ref->addr, name? name: "?");
}
name = axtm_name (core, ref->at);
r_cons_printf (" 0x%"PFMT64x": %s\n", ref->at, name? name: "?");
last_addr = ref->addr;
}
}
RVecAnalRef_free (refs);
} | Base | 1 |
func (cr *collectionRepo) AddCollection(ctx context.Context, collection *entity.Collection) (err error) {
id, err := cr.uniqueIDRepo.GenUniqueIDStr(ctx, collection.TableName())
if err == nil {
collection.ID = id
_, err = cr.data.DB.Insert(collection)
if err != nil {
return errors.InternalServer(reason.DatabaseError).WithError(err).WithStack()
}
}
return nil
} | Class | 2 |
func (uc *UserController) RetrievePassWord(ctx *gin.Context) {
req := &schema.UserRetrievePassWordRequest{}
if handler.BindAndCheck(ctx, req) {
return
}
captchaPass := uc.actionService.ActionRecordVerifyCaptcha(ctx, schema.ActionRecordTypeFindPass, ctx.ClientIP(), req.CaptchaID, req.CaptchaCode)
if !captchaPass {
errFields := append([]*validator.FormErrorField{}, &validator.FormErrorField{
ErrorField: "captcha_code",
ErrorMsg: translator.Tr(handler.GetLang(ctx), reason.CaptchaVerificationFailed),
})
handler.HandleResponse(ctx, errors.BadRequest(reason.CaptchaVerificationFailed), errFields)
return
}
_, _ = uc.actionService.ActionRecordAdd(ctx, schema.ActionRecordTypeFindPass, ctx.ClientIP())
code, err := uc.userService.RetrievePassWord(ctx, req)
handler.HandleResponse(ctx, err, code)
} | Pillar | 3 |
func (sc *SiteInfoController) UpdateGeneral(ctx *gin.Context) {
req := schema.SiteGeneralReq{}
if handler.BindAndCheck(ctx, &req) {
return
}
err := sc.siteInfoService.SaveSiteGeneral(ctx, req)
handler.HandleResponse(ctx, err, nil)
} | Base | 1 |
func (req *UpdateInfoRequest) Check() (errFields []*validator.FormErrorField, err error) {
if len(req.Username) > 0 {
if checker.IsInvalidUsername(req.Username) {
errField := &validator.FormErrorField{
ErrorField: "username",
ErrorMsg: reason.UsernameInvalid,
}
errFields = append(errFields, errField)
return errFields, errors.BadRequest(reason.UsernameInvalid)
}
}
req.BioHTML = converter.Markdown2HTML(req.Bio)
return nil, nil
} | Base | 1 |
func (uc *UserController) RetrievePassWord(ctx *gin.Context) {
req := &schema.UserRetrievePassWordRequest{}
if handler.BindAndCheck(ctx, req) {
return
}
captchaPass := uc.actionService.ActionRecordVerifyCaptcha(ctx, schema.ActionRecordTypeFindPass, ctx.ClientIP(), req.CaptchaID, req.CaptchaCode)
if !captchaPass {
errFields := append([]*validator.FormErrorField{}, &validator.FormErrorField{
ErrorField: "captcha_code",
ErrorMsg: translator.Tr(handler.GetLang(ctx), reason.CaptchaVerificationFailed),
})
handler.HandleResponse(ctx, errors.BadRequest(reason.CaptchaVerificationFailed), errFields)
return
}
_, _ = uc.actionService.ActionRecordAdd(ctx, schema.ActionRecordTypeFindPass, ctx.ClientIP())
_, err := uc.userService.RetrievePassWord(ctx, req)
handler.HandleResponse(ctx, err, nil)
} | Base | 1 |
func (us *UserService) RetrievePassWord(ctx context.Context, req *schema.UserRetrievePassWordRequest) (string, error) {
userInfo, has, err := us.userRepo.GetByEmail(ctx, req.Email)
if err != nil {
return "", err
}
if !has {
return "", errors.BadRequest(reason.UserNotFound)
}
// send email
data := &schema.EmailCodeContent{
Email: req.Email,
UserID: userInfo.ID,
}
code := uuid.NewString()
verifyEmailURL := fmt.Sprintf("%s/users/password-reset?code=%s", us.getSiteUrl(ctx), code)
title, body, err := us.emailService.PassResetTemplate(ctx, verifyEmailURL)
if err != nil {
return "", err
}
go us.emailService.SendAndSaveCode(ctx, req.Email, title, body, code, data.ToJSONString())
return code, nil
} | Base | 1 |
func (tr *GetTagResp) GetExcerpt() {
excerpt := strings.TrimSpace(tr.OriginalText)
idx := strings.Index(excerpt, "\n")
if idx >= 0 {
excerpt = excerpt[0:idx]
}
tr.Excerpt = excerpt
} | Base | 1 |
func (tr *GetTagResp) GetExcerpt() {
excerpt := strings.TrimSpace(tr.OriginalText)
idx := strings.Index(excerpt, "\n")
if idx >= 0 {
excerpt = excerpt[0:idx]
}
tr.Excerpt = excerpt
} | Base | 1 |
func (tr *GetTagResp) GetExcerpt() {
excerpt := strings.TrimSpace(tr.OriginalText)
idx := strings.Index(excerpt, "\n")
if idx >= 0 {
excerpt = excerpt[0:idx]
}
tr.Excerpt = excerpt
} | Base | 1 |
func Markdown2HTML(source string) string {
mdConverter := goldmark.New(
goldmark.WithExtensions(&DangerousHTMLFilterExtension{}, extension.GFM),
goldmark.WithParserOptions(
parser.WithAutoHeadingID(),
),
goldmark.WithRendererOptions(
goldmarkHTML.WithHardWraps(),
),
)
var buf bytes.Buffer
if err := mdConverter.Convert([]byte(source), &buf); err != nil {
log.Error(err)
return source
}
return buf.String()
} | Base | 1 |
func Markdown2HTML(source string) string {
mdConverter := goldmark.New(
goldmark.WithExtensions(&DangerousHTMLFilterExtension{}, extension.GFM),
goldmark.WithParserOptions(
parser.WithAutoHeadingID(),
),
goldmark.WithRendererOptions(
goldmarkHTML.WithHardWraps(),
),
)
var buf bytes.Buffer
if err := mdConverter.Convert([]byte(source), &buf); err != nil {
log.Error(err)
return source
}
return buf.String()
} | Base | 1 |
func (uc *UserController) UseRePassWord(ctx *gin.Context) {
req := &schema.UserRePassWordRequest{}
if handler.BindAndCheck(ctx, req) {
return
}
req.Content = uc.emailService.VerifyUrlExpired(ctx, req.Code)
if len(req.Content) == 0 {
handler.HandleResponse(ctx, errors.Forbidden(reason.EmailVerifyURLExpired),
&schema.ForbiddenResp{Type: schema.ForbiddenReasonTypeURLExpired})
return
}
resp, err := uc.userService.UseRePassword(ctx, req)
uc.actionService.ActionRecordDel(ctx, schema.ActionRecordTypeFindPass, ctx.ClientIP())
handler.HandleResponse(ctx, err, resp)
} | Base | 1 |
func (uc *UserController) UserModifyPassWord(ctx *gin.Context) {
req := &schema.UserModifyPassWordRequest{}
if handler.BindAndCheck(ctx, req) {
return
}
req.UserID = middleware.GetLoginUserIDFromContext(ctx)
oldPassVerification, err := uc.userService.UserModifyPassWordVerification(ctx, req)
if err != nil {
handler.HandleResponse(ctx, err, nil)
return
}
if !oldPassVerification {
errFields := append([]*validator.FormErrorField{}, &validator.FormErrorField{
ErrorField: "old_pass",
ErrorMsg: translator.Tr(handler.GetLang(ctx), reason.OldPasswordVerificationFailed),
})
handler.HandleResponse(ctx, errors.BadRequest(reason.OldPasswordVerificationFailed), errFields)
return
}
if req.OldPass == req.Pass {
errFields := append([]*validator.FormErrorField{}, &validator.FormErrorField{
ErrorField: "pass",
ErrorMsg: translator.Tr(handler.GetLang(ctx), reason.NewPasswordSameAsPreviousSetting),
})
handler.HandleResponse(ctx, errors.BadRequest(reason.NewPasswordSameAsPreviousSetting), errFields)
return
}
err = uc.userService.UserModifyPassword(ctx, req)
handler.HandleResponse(ctx, err, nil)
} | Base | 1 |
func (ar *authRepo) RemoveUserTokens(ctx context.Context, userID string) {
key := constant.UserTokenMappingCacheKey + userID
resp, _ := ar.data.Cache.GetString(ctx, key)
mapping := make(map[string]bool, 0)
if len(resp) > 0 {
_ = json.Unmarshal([]byte(resp), &mapping)
log.Debugf("find %d user tokens by user id %s", len(mapping), userID)
}
for token := range mapping {
if err := ar.RemoveUserCacheInfo(ctx, token); err != nil {
log.Error(err)
} else {
log.Debugf("del user %s token success")
}
}
if err := ar.RemoveUserStatus(ctx, userID); err != nil {
log.Error(err)
}
if err := ar.data.Cache.Del(ctx, key); err != nil {
log.Error(err)
}
} | Base | 1 |
func (u *UserModifyPassWordRequest) Check() (errFields []*validator.FormErrorField, err error) {
// TODO i18n
err = checker.CheckPassword(8, 32, 0, u.Pass)
if err != nil {
errField := &validator.FormErrorField{
ErrorField: "pass",
ErrorMsg: err.Error(),
}
errFields = append(errFields, errField)
return errFields, err
}
return nil, nil
} | Base | 1 |
func (as *AuthService) RemoveUserTokens(ctx context.Context, userID string) {
as.authRepo.RemoveUserTokens(ctx, userID)
} | Base | 1 |
func (us *UserAdminService) UpdateUserPassword(ctx context.Context, req *schema.UpdateUserPasswordReq) (err error) {
// Users cannot modify their password
if req.UserID == req.LoginUserID {
return errors.BadRequest(reason.AdminCannotUpdateTheirPassword)
}
userInfo, exist, err := us.userRepo.GetUserInfo(ctx, req.UserID)
if err != nil {
return err
}
if !exist {
return errors.BadRequest(reason.UserNotFound)
}
hashPwd, err := bcrypt.GenerateFromPassword([]byte(req.Password), bcrypt.DefaultCost)
if err != nil {
return err
}
err = us.userRepo.UpdateUserPassword(ctx, userInfo.ID, string(hashPwd))
if err != nil {
return err
}
// logout this user
us.authService.RemoveUserTokens(ctx, req.UserID)
return
} | Base | 1 |
func (us *UserAdminService) UpdateUserRole(ctx context.Context, req *schema.UpdateUserRoleReq) (err error) {
// Users cannot modify their roles
if req.UserID == req.LoginUserID {
return errors.BadRequest(reason.UserCannotUpdateYourRole)
}
err = us.userRoleRelService.SaveUserRole(ctx, req.UserID, req.RoleID)
if err != nil {
return err
}
us.authService.RemoveUserTokens(ctx, req.UserID)
return
} | Base | 1 |
func (us *UserService) UserModifyPassword(ctx context.Context, request *schema.UserModifyPassWordRequest) error {
enpass, err := us.encryptPassword(ctx, request.Pass)
if err != nil {
return err
}
userInfo, has, err := us.userRepo.GetByUserID(ctx, request.UserID)
if err != nil {
return err
}
if !has {
return fmt.Errorf("user does not exist")
}
isPass := us.verifyPassword(ctx, request.OldPass, userInfo.Pass)
if !isPass {
return fmt.Errorf("the old password verification failed")
}
err = us.userRepo.UpdatePass(ctx, userInfo.ID, enpass)
if err != nil {
return err
}
return nil
} | Base | 1 |
func (us *UserService) UserModifyPassWordVerification(ctx context.Context, request *schema.UserModifyPassWordRequest) (bool, error) {
userInfo, has, err := us.userRepo.GetByUserID(ctx, request.UserID)
if err != nil {
return false, err
}
if !has {
return false, fmt.Errorf("user does not exist")
}
isPass := us.verifyPassword(ctx, request.OldPass, userInfo.Pass)
if !isPass {
return false, nil
}
return true, nil
} | Base | 1 |
func (us *UserService) UseRePassword(ctx context.Context, req *schema.UserRePassWordRequest) (resp *schema.GetUserResp, err error) {
data := &schema.EmailCodeContent{}
err = data.FromJSONString(req.Content)
if err != nil {
return nil, errors.BadRequest(reason.EmailVerifyURLExpired)
}
userInfo, exist, err := us.userRepo.GetByEmail(ctx, data.Email)
if err != nil {
return nil, err
}
if !exist {
return nil, errors.BadRequest(reason.UserNotFound)
}
enpass, err := us.encryptPassword(ctx, req.Pass)
if err != nil {
return nil, err
}
err = us.userRepo.UpdatePass(ctx, userInfo.ID, enpass)
if err != nil {
return nil, err
}
resp = &schema.GetUserResp{}
return resp, nil
} | Base | 1 |
func (us *UserService) verifyPassword(ctx context.Context, LoginPass, UserPass string) bool {
err := bcrypt.CompareHashAndPassword([]byte(UserPass), []byte(LoginPass))
return err == nil
} | Base | 1 |
func (m *MyValidator) Check(value interface{}) (errFields []*FormErrorField, err error) {
err = m.Validate.Struct(value)
if err != nil {
var valErrors validator.ValidationErrors
if !errors.As(err, &valErrors) {
log.Error(err)
return nil, errors.New("validate check exception")
}
for _, fieldError := range valErrors {
errField := &FormErrorField{
ErrorField: fieldError.Field(),
ErrorMsg: fieldError.Translate(m.Tran),
}
// get original tag name from value for set err field key.
structNamespace := fieldError.StructNamespace()
_, fieldName, found := strings.Cut(structNamespace, ".")
if found {
originalTag := getObjectTagByFieldName(value, fieldName)
if len(originalTag) > 0 {
errField.ErrorField = originalTag
}
}
errFields = append(errFields, errField)
}
if len(errFields) > 0 {
errMsg := ""
if len(errFields) == 1 {
errMsg = errFields[0].ErrorMsg
}
return errFields, myErrors.BadRequest(reason.RequestFormatError).WithMsg(errMsg)
}
}
if v, ok := value.(Checker); ok {
errFields, err = v.Check()
if err == nil {
return nil, nil
}
for _, errField := range errFields {
errField.ErrorMsg = translator.Tr(m.Lang, errField.ErrorMsg)
}
return errFields, err
}
return nil, nil
} | Base | 1 |
func (u *UserRePassWordRequest) Check() (errFields []*validator.FormErrorField, err error) {
// TODO i18n
err = checker.CheckPassword(8, 32, 0, u.Pass)
if err != nil {
errField := &validator.FormErrorField{
ErrorField: "pass",
ErrorMsg: err.Error(),
}
errFields = append(errFields, errField)
return errFields, err
}
return nil, nil
} | Base | 1 |
func (u *UserModifyPasswordReq) Check() (errFields []*validator.FormErrorField, err error) {
// TODO i18n
err = checker.CheckPassword(8, 32, 0, u.Pass)
if err != nil {
errField := &validator.FormErrorField{
ErrorField: "pass",
ErrorMsg: err.Error(),
}
errFields = append(errFields, errField)
return errFields, err
}
return nil, nil
} | Base | 1 |
func (u *UserRegisterReq) Check() (errFields []*validator.FormErrorField, err error) {
// TODO i18n
err = checker.CheckPassword(8, 32, 0, u.Pass)
if err != nil {
errField := &validator.FormErrorField{
ErrorField: "pass",
ErrorMsg: err.Error(),
}
errFields = append(errFields, errField)
return errFields, err
}
return nil, nil
} | Base | 1 |
func (vc *VoteController) VoteDown(ctx *gin.Context) {
req := &schema.VoteReq{}
if handler.BindAndCheck(ctx, req) {
return
}
req.ObjectID = uid.DeShortID(req.ObjectID)
req.UserID = middleware.GetLoginUserIDFromContext(ctx)
can, needRank, err := vc.rankService.CheckVotePermission(ctx, req.UserID, req.ObjectID, false)
if err != nil {
handler.HandleResponse(ctx, err, nil)
return
}
if !can {
lang := handler.GetLang(ctx)
msg := translator.TrWithData(lang, reason.NoEnoughRankToOperate, &schema.PermissionTrTplData{Rank: needRank})
handler.HandleResponse(ctx, errors.Forbidden(reason.NoEnoughRankToOperate).WithMsg(msg), nil)
return
}
dto := &schema.VoteDTO{}
_ = copier.Copy(dto, req)
resp, err := vc.VoteService.VoteDown(ctx, dto)
if err != nil {
handler.HandleResponse(ctx, err, schema.ErrTypeToast)
} else {
handler.HandleResponse(ctx, err, resp)
}
} | Base | 1 |
func (vc *VoteController) VoteUp(ctx *gin.Context) {
req := &schema.VoteReq{}
if handler.BindAndCheck(ctx, req) {
return
}
req.ObjectID = uid.DeShortID(req.ObjectID)
req.UserID = middleware.GetLoginUserIDFromContext(ctx)
can, needRank, err := vc.rankService.CheckVotePermission(ctx, req.UserID, req.ObjectID, true)
if err != nil {
handler.HandleResponse(ctx, err, nil)
return
}
if !can {
lang := handler.GetLang(ctx)
msg := translator.TrWithData(lang, reason.NoEnoughRankToOperate, &schema.PermissionTrTplData{Rank: needRank})
handler.HandleResponse(ctx, errors.Forbidden(reason.NoEnoughRankToOperate).WithMsg(msg), nil)
return
}
dto := &schema.VoteDTO{}
_ = copier.Copy(dto, req)
resp, err := vc.VoteService.VoteUp(ctx, dto)
if err != nil {
handler.HandleResponse(ctx, err, schema.ErrTypeToast)
} else {
handler.HandleResponse(ctx, err, resp)
}
} | Base | 1 |
func (ar *AnswerActivityRepo) DeleteQuestion(ctx context.Context, questionID string) (err error) {
questionInfo := &entity.Question{}
exist, err := ar.data.DB.Context(ctx).Where("id = ?", questionID).Get(questionInfo)
if err != nil {
return errors.InternalServer(reason.DatabaseError).WithError(err).WithStack()
}
if !exist {
return nil
}
// get all this object activity
activityList := make([]*entity.Activity, 0)
session := ar.data.DB.Context(ctx).Where("has_rank = 1")
session.Where("cancelled = ?", entity.ActivityAvailable)
err = session.Find(&activityList, &entity.Activity{ObjectID: questionID})
if err != nil {
return errors.InternalServer(reason.DatabaseError).WithError(err).WithStack()
}
if len(activityList) == 0 {
return nil
}
log.Infof("questionInfo %s deleted will rollback activity %d", questionID, len(activityList))
_, err = ar.data.DB.Transaction(func(session *xorm.Session) (result any, err error) {
session = session.Context(ctx)
for _, act := range activityList {
log.Infof("user %s rollback rank %d", act.UserID, -act.Rank)
_, e := ar.userRankRepo.TriggerUserRank(
ctx, session, act.UserID, -act.Rank, act.ActivityType)
if e != nil {
return nil, errors.InternalServer(reason.DatabaseError).WithError(e).WithStack()
}
if _, e := session.Where("id = ?", act.ID).Cols("cancelled", "cancelled_at").
Update(&entity.Activity{Cancelled: entity.ActivityCancelled, CancelledAt: time.Now()}); e != nil {
return nil, errors.InternalServer(reason.DatabaseError).WithError(e).WithStack()
}
}
return nil, nil
})
if err != nil {
return err
}
// get all answers
answerList := make([]*entity.Answer, 0)
err = ar.data.DB.Context(ctx).Find(&answerList, &entity.Answer{QuestionID: questionID})
if err != nil {
return errors.InternalServer(reason.DatabaseError).WithError(err).WithStack()
}
for _, answerInfo := range answerList {
err = ar.DeleteAnswer(ctx, answerInfo.ID)
if err != nil {
log.Error(err)
}
}
return
} | Base | 1 |
func NewQuestionActivityRepo(
data *data.Data,
activityRepo activity_common.ActivityRepo,
userRankRepo rank.UserRankRepo,
) activity.QuestionActivityRepo {
return &AnswerActivityRepo{
data: data,
activityRepo: activityRepo,
userRankRepo: userRankRepo,
}
} | Base | 1 |
func (ar *AnswerActivityRepo) DeleteAnswer(ctx context.Context, answerID string) (err error) {
answerInfo := &entity.Answer{}
exist, err := ar.data.DB.Context(ctx).Where("id = ?", answerID).Get(answerInfo)
if err != nil {
return errors.InternalServer(reason.DatabaseError).WithError(err).WithStack()
}
if !exist {
return nil
}
// get all this object activity
activityList := make([]*entity.Activity, 0)
session := ar.data.DB.Context(ctx).Where("has_rank = 1")
session.Where("cancelled = ?", entity.ActivityAvailable)
err = session.Find(&activityList, &entity.Activity{ObjectID: answerID})
if err != nil {
return errors.InternalServer(reason.DatabaseError).WithError(err).WithStack()
}
if len(activityList) == 0 {
return nil
}
log.Infof("answerInfo %s deleted will rollback activity %d", answerID, len(activityList))
_, err = ar.data.DB.Transaction(func(session *xorm.Session) (result any, err error) {
session = session.Context(ctx)
for _, act := range activityList {
log.Infof("user %s rollback rank %d", act.UserID, -act.Rank)
_, e := ar.userRankRepo.TriggerUserRank(
ctx, session, act.UserID, -act.Rank, act.ActivityType)
if e != nil {
return nil, errors.InternalServer(reason.DatabaseError).WithError(e).WithStack()
}
if _, e := session.Where("id = ?", act.ID).Cols("cancelled", "cancelled_at").
Update(&entity.Activity{Cancelled: entity.ActivityCancelled, CancelledAt: time.Now()}); e != nil {
return nil, errors.InternalServer(reason.DatabaseError).WithError(e).WithStack()
}
}
return nil, nil
})
if err != nil {
return err
}
return
} | Base | 1 |
func (ar *FollowRepo) FollowCancel(ctx context.Context, objectID, userID string) error {
objectTypeStr, err := obj.GetObjectTypeStrByObjectID(objectID)
if err != nil {
return errors.InternalServer(reason.DatabaseError).WithError(err).WithStack()
}
activityType, err := ar.activityRepo.GetActivityTypeByObjKey(ctx, objectTypeStr, "follow")
if err != nil {
return err
}
_, err = ar.data.DB.Transaction(func(session *xorm.Session) (result any, err error) {
session = session.Context(ctx)
var (
existsActivity entity.Activity
has bool
)
result = nil
has, err = session.Where(builder.Eq{"activity_type": activityType}).
And(builder.Eq{"user_id": userID}).
And(builder.Eq{"object_id": objectID}).
Get(&existsActivity)
if err != nil || !has {
return
}
if has && existsActivity.Cancelled == entity.ActivityCancelled {
return
}
if _, err = session.Where("id = ?", existsActivity.ID).
Cols("cancelled").
Update(&entity.Activity{
Cancelled: entity.ActivityCancelled,
CancelledAt: time.Now(),
}); err != nil {
return
}
err = ar.updateFollows(ctx, session, objectID, -1)
return
})
return err
} | Base | 1 |
func (ar *FollowRepo) Follow(ctx context.Context, objectID, userID string) error {
objectTypeStr, err := obj.GetObjectTypeStrByObjectID(objectID)
if err != nil {
return errors.InternalServer(reason.DatabaseError).WithError(err).WithStack()
}
activityType, err := ar.activityRepo.GetActivityTypeByObjKey(ctx, objectTypeStr, "follow")
if err != nil {
return err
}
_, err = ar.data.DB.Transaction(func(session *xorm.Session) (result any, err error) {
session = session.Context(ctx)
var (
existsActivity entity.Activity
has bool
)
result = nil
has, err = session.Where(builder.Eq{"activity_type": activityType}).
And(builder.Eq{"user_id": userID}).
And(builder.Eq{"object_id": objectID}).
Get(&existsActivity)
if err != nil {
return
}
if has && existsActivity.Cancelled == entity.ActivityAvailable {
return
}
if has {
_, err = session.Where(builder.Eq{"id": existsActivity.ID}).
Cols(`cancelled`).
Update(&entity.Activity{
Cancelled: entity.ActivityAvailable,
})
} else {
// update existing activity with new user id and u object id
_, err = session.Insert(&entity.Activity{
UserID: userID,
ObjectID: objectID,
OriginalObjectID: objectID,
ActivityType: activityType,
Cancelled: entity.ActivityAvailable,
Rank: 0,
HasRank: 0,
})
}
if err != nil {
log.Error(err)
return
}
// start update followers when everything is fine
err = ar.updateFollows(ctx, session, objectID, 1)
if err != nil {
log.Error(err)
}
return
})
return err
} | Base | 1 |
func (ar *UserActiveActivityRepo) UserActive(ctx context.Context, userID string) (err error) {
cfg, err := ar.configService.GetConfigByKey(ctx, UserActivated)
if err != nil {
return err
}
activityType := cfg.ID
deltaRank := cfg.GetIntValue()
addActivity := &entity.Activity{
UserID: userID,
ObjectID: "0",
OriginalObjectID: "0",
ActivityType: activityType,
Rank: deltaRank,
HasRank: 1,
}
_, err = ar.data.DB.Transaction(func(session *xorm.Session) (result any, err error) {
session = session.Context(ctx)
_, exists, err := ar.activityRepo.GetActivity(ctx, session, "0", addActivity.UserID, activityType)
if err != nil {
return nil, errors.InternalServer(reason.DatabaseError).WithError(err).WithStack()
}
if exists {
return nil, nil
}
_, err = ar.userRankRepo.TriggerUserRank(ctx, session, addActivity.UserID, addActivity.Rank, activityType)
if err != nil {
return nil, errors.InternalServer(reason.DatabaseError).WithError(err).WithStack()
}
_, err = session.Insert(addActivity)
if err != nil {
return nil, errors.InternalServer(reason.DatabaseError).WithError(err).WithStack()
}
return nil, nil
})
return err
} | Base | 1 |
func (vr *VoteRepo) ListUserVotes(ctx context.Context, userID string,
page int, pageSize int, activityTypes []int) (voteList []entity.Activity, total int64, err error) {
session := vr.data.DB.Context(ctx)
cond := builder.
And(
builder.Eq{"user_id": userID},
builder.Eq{"cancelled": 0},
builder.In("activity_type", activityTypes),
)
session.Where(cond).Desc("updated_at")
total, err = pager.Help(page, pageSize, &voteList, &entity.Activity{}, session)
if err != nil {
err = errors.InternalServer(reason.DatabaseError).WithError(err).WithStack()
}
return
} | Base | 1 |
func (vr *VoteRepo) VoteDownCancel(ctx context.Context, objectID string, userID, objectUserID string) (resp *schema.VoteResp, err error) {
var objectType string
resp = &schema.VoteResp{}
objectType, err = obj.GetObjectTypeStrByObjectID(objectID)
if err != nil {
err = errors.BadRequest(reason.ObjectNotFound)
return
}
actions, ok := LimitDownActions[objectType]
if !ok {
err = errors.BadRequest(reason.DisallowVote)
return
}
return vr.voteCancel(ctx, objectID, userID, objectUserID, actions)
} | Base | 1 |
func NewVoteRepo(
data *data.Data,
uniqueIDRepo unique.UniqueIDRepo,
configService *config.ConfigService,
activityRepo activity_common.ActivityRepo,
userRankRepo rank.UserRankRepo,
voteCommon activity_common.VoteRepo,
notificationQueueService notice_queue.NotificationQueueService,
) service.VoteRepo {
return &VoteRepo{
data: data,
uniqueIDRepo: uniqueIDRepo,
configService: configService,
activityRepo: activityRepo,
userRankRepo: userRankRepo,
voteCommon: voteCommon,
notificationQueueService: notificationQueueService,
}
} | Base | 1 |
func (vr *VoteRepo) updateVotes(ctx context.Context, session *xorm.Session, objectID string, votes int) (err error) {
var (
objectType string
e error
)
objectType, err = obj.GetObjectTypeStrByObjectID(objectID)
switch objectType {
case "question":
_, err = session.Where("id = ?", objectID).Incr("vote_count", votes).Update(&entity.Question{})
case "answer":
_, err = session.Where("id = ?", objectID).Incr("vote_count", votes).Update(&entity.Answer{})
case "comment":
_, err = session.Where("id = ?", objectID).Incr("vote_count", votes).Update(&entity.Comment{})
default:
e = errors.BadRequest(reason.DisallowVote)
}
if e != nil {
err = e
} else if err != nil {
err = errors.BadRequest(reason.DatabaseError).WithError(err).WithStack()
}
return
} | Base | 1 |
func (vr *VoteRepo) sendNotification(ctx context.Context, activityUserID, objectUserID, objectID string) {
objectType, err := obj.GetObjectTypeStrByObjectID(objectID)
if err != nil {
return
}
msg := &schema.NotificationMsg{
ReceiverUserID: activityUserID,
TriggerUserID: objectUserID,
Type: schema.NotificationTypeAchievement,
ObjectID: objectID,
ObjectType: objectType,
}
vr.notificationQueueService.Send(ctx, msg)
} | Base | 1 |
func (vr *VoteRepo) VoteUp(ctx context.Context, objectID string, userID, objectUserID string) (resp *schema.VoteResp, err error) {
resp = &schema.VoteResp{}
objectType, err := obj.GetObjectTypeStrByObjectID(objectID)
if err != nil {
err = errors.BadRequest(reason.ObjectNotFound)
return
}
actions, ok := LimitUpActions[objectType]
if !ok {
err = errors.BadRequest(reason.DisallowVote)
return
}
_, _ = vr.VoteDownCancel(ctx, objectID, userID, objectUserID)
return vr.vote(ctx, objectID, userID, objectUserID, actions)
} | Base | 1 |
func (vr *VoteRepo) VoteDown(ctx context.Context, objectID string, userID, objectUserID string) (resp *schema.VoteResp, err error) {
resp = &schema.VoteResp{}
objectType, err := obj.GetObjectTypeStrByObjectID(objectID)
if err != nil {
err = errors.BadRequest(reason.ObjectNotFound)
return
}
actions, ok := LimitDownActions[objectType]
if !ok {
err = errors.BadRequest(reason.DisallowVote)
return
}
_, _ = vr.VoteUpCancel(ctx, objectID, userID, objectUserID)
return vr.vote(ctx, objectID, userID, objectUserID, actions)
} | Base | 1 |
func (vr *VoteRepo) VoteUpCancel(ctx context.Context, objectID string, userID, objectUserID string) (resp *schema.VoteResp, err error) {
var objectType string
resp = &schema.VoteResp{}
objectType, err = obj.GetObjectTypeStrByObjectID(objectID)
if err != nil {
err = errors.BadRequest(reason.ObjectNotFound)
return
}
actions, ok := LimitUpActions[objectType]
if !ok {
err = errors.BadRequest(reason.DisallowVote)
return
}
return vr.voteCancel(ctx, objectID, userID, objectUserID, actions)
} | Base | 1 |
func (vr *VoteRepo) GetVoteResultByObjectId(ctx context.Context, objectID string) (resp *schema.VoteResp, err error) {
resp = &schema.VoteResp{}
for _, action := range []string{"vote_up", "vote_down"} {
var (
activity entity.Activity
votes int64
activityType int
)
activityType, _, _, _ = vr.activityRepo.GetActivityTypeByObjID(ctx, objectID, action)
votes, err = vr.data.DB.Context(ctx).Where(builder.Eq{"object_id": objectID}).
And(builder.Eq{"activity_type": activityType}).
And(builder.Eq{"cancelled": 0}).
Count(&activity)
if err != nil {
return
}
if action == "vote_up" {
resp.UpVotes = int(votes)
} else {
resp.DownVotes = int(votes)
}
}
resp.Votes = resp.UpVotes - resp.DownVotes
return resp, nil
} | Base | 1 |
func (vr *VoteRepo) CheckRank(ctx context.Context, objectID, objectUserID, userID string, action string) (activityUserID string, activityType, rank, hasRank int, err error) {
activityType, rank, hasRank, err = vr.activityRepo.GetActivityTypeByObjID(ctx, objectID, action)
if err != nil {
return
}
activityUserID = userID
if strings.Contains(action, "voted") {
activityUserID = objectUserID
}
return activityUserID, activityType, rank, hasRank, nil
} | Base | 1 |
func (ar *ActivityRepo) GetActivityTypeByObjID(ctx context.Context, objectID string, action string) (
activityType, rank, hasRank int, err error) {
objectKey, err := obj.GetObjectTypeStrByObjectID(objectID)
if err != nil {
return
}
confKey := fmt.Sprintf("%s.%s", objectKey, action)
cfg, err := ar.configService.GetConfigByKey(ctx, confKey)
if err != nil {
return
}
activityType, rank = cfg.ID, cfg.GetIntValue()
hasRank = 0
if rank != 0 {
hasRank = 1
}
return
} | Base | 1 |
func (ar *ActivityRepo) GetActivityTypeByObjKey(ctx context.Context, objectKey, action string) (activityType int, err error) {
configKey := fmt.Sprintf("%s.%s", objectKey, action)
cfg, err := ar.configService.GetConfigByKey(ctx, configKey)
if err != nil {
return 0, errors.InternalServer(reason.DatabaseError).WithError(err).WithStack()
}
return cfg.ID, nil
} | Base | 1 |
func (ar *FollowRepo) IsFollowed(ctx context.Context, userID, objectID string) (followed bool, err error) {
objectKey, err := obj.GetObjectTypeStrByObjectID(objectID)
if err != nil {
return false, err
}
activityType, err := ar.activityRepo.GetActivityTypeByObjKey(ctx, objectKey, "follow")
if err != nil {
return false, err
}
at := &entity.Activity{}
has, err := ar.data.DB.Context(ctx).Where("user_id = ? AND object_id = ? AND activity_type = ?", userID, objectID, activityType).Get(at)
if err != nil {
return false, err
}
if !has {
return false, nil
}
if at.Cancelled == entity.ActivityCancelled {
return false, nil
} else {
return true, nil
}
} | Base | 1 |
func (ar *FollowRepo) GetFollowUserIDs(ctx context.Context, objectID string) (userIDs []string, err error) {
objectTypeStr, err := obj.GetObjectTypeStrByObjectID(objectID)
if err != nil {
return nil, err
}
activityType, err := ar.activityRepo.GetActivityTypeByObjKey(ctx, objectTypeStr, "follow")
if err != nil {
log.Errorf("can't get activity type by object key: %s", objectTypeStr)
return nil, err
}
userIDs = make([]string, 0)
session := ar.data.DB.Context(ctx).Select("user_id")
session.Table(entity.Activity{}.TableName())
session.Where("object_id = ?", objectID)
session.Where("activity_type = ?", activityType)
session.Where("cancelled = 0")
err = session.Find(&userIDs)
if err != nil {
return nil, errors.InternalServer(reason.DatabaseError).WithError(err).WithStack()
}
return userIDs, nil
} | Base | 1 |
func (ar *FollowRepo) GetFollowIDs(ctx context.Context, userID, objectKey string) (followIDs []string, err error) {
followIDs = make([]string, 0)
activityType, err := ar.activityRepo.GetActivityTypeByObjKey(ctx, objectKey, "follow")
if err != nil {
return nil, errors.InternalServer(reason.DatabaseError).WithError(err).WithStack()
}
session := ar.data.DB.Context(ctx).Select("object_id")
session.Table(entity.Activity{}.TableName())
session.Where("user_id = ? AND activity_type = ?", userID, activityType)
session.Where("cancelled = 0")
err = session.Find(&followIDs)
if err != nil {
return nil, errors.InternalServer(reason.DatabaseError).WithError(err).WithStack()
}
return followIDs, nil
} | Base | 1 |
func (ur *UserRankRepo) TriggerUserRank(ctx context.Context,
session *xorm.Session, userID string, deltaRank int, activityType int,
) (isReachStandard bool, err error) {
// IMPORTANT: If user center enabled the rank agent, then we should not change user rank.
if plugin.RankAgentEnabled() {
return false, nil
}
if deltaRank == 0 {
return false, nil
}
if deltaRank < 0 {
// if user rank is lower than 1 after this action, then user rank will be set to 1 only.
var isReachMin bool
isReachMin, err = ur.checkUserMinRank(ctx, session, userID, deltaRank)
if err != nil {
return false, errors.InternalServer(reason.DatabaseError).WithError(err).WithStack()
}
if isReachMin {
_, err = session.Where(builder.Eq{"id": userID}).Update(&entity.User{Rank: 1})
if err != nil {
return false, errors.InternalServer(reason.DatabaseError).WithError(err).WithStack()
}
return true, nil
}
} else {
isReachStandard, err = ur.checkUserTodayRank(ctx, session, userID, activityType)
if err != nil {
return false, errors.InternalServer(reason.DatabaseError).WithError(err).WithStack()
}
if isReachStandard {
return isReachStandard, nil
}
}
_, err = session.Where(builder.Eq{"id": userID}).Incr("`rank`", deltaRank).Update(&entity.User{})
if err != nil {
return false, errors.InternalServer(reason.DatabaseError).WithError(err).WithStack()
}
return false, nil
} | Base | 1 |
func (ur *userRepo) GetByUsernames(ctx context.Context, usernames []string) ([]*entity.User, error) {
list := make([]*entity.User, 0)
err := ur.data.DB.Where("status =?", entity.UserStatusAvailable).In("username", usernames).Find(&list)
if err != nil {
err = errors.InternalServer(reason.DatabaseError).WithError(err).WithStack()
return list, err
}
tryToDecorateUserListFromUserCenter(ctx, ur.data, list)
return list, nil
} | Base | 1 |
func NewAnswerActivityService(
answerActivityRepo AnswerActivityRepo, questionActivityRepo QuestionActivityRepo) *AnswerActivityService {
return &AnswerActivityService{
answerActivityRepo: answerActivityRepo,
questionActivityRepo: questionActivityRepo,
}
} | Base | 1 |
func (as *AnswerActivityService) DeleteQuestion(ctx context.Context, questionID string, createdAt time.Time,
voteCount int) (err error) {
if voteCount >= 3 {
log.Infof("There is no need to roll back the reputation by answering likes above the target value. %s %d", questionID, voteCount)
return nil
}
if createdAt.Before(time.Now().AddDate(0, 0, -60)) {
log.Infof("There is no need to roll back the reputation by answer's existence time meets the target. %s %s", questionID, createdAt.String())
return nil
}
return as.questionActivityRepo.DeleteQuestion(ctx, questionID)
} | Base | 1 |
func (as *AnswerActivityService) DeleteAnswer(ctx context.Context, answerID string, createdAt time.Time,
voteCount int) (err error) {
if voteCount >= 3 {
log.Infof("There is no need to roll back the reputation by answering likes above the target value. %s %d", answerID, voteCount)
return nil
}
if createdAt.Before(time.Now().AddDate(0, 0, -60)) {
log.Infof("There is no need to roll back the reputation by answer's existence time meets the target. %s %s", answerID, createdAt.String())
return nil
}
return as.answerActivityRepo.DeleteAnswer(ctx, answerID)
} | Base | 1 |
func (vs *VoteService) GetObjectUserID(ctx context.Context, objectID string) (userID string, err error) {
var objectKey string
objectKey, err = obj.GetObjectTypeStrByObjectID(objectID)
if err != nil {
err = nil
return
}
switch objectKey {
case "question":
object, has, e := vs.questionRepo.GetQuestion(ctx, objectID)
if e != nil || !has {
err = errors.BadRequest(reason.QuestionNotFound).WithError(e).WithStack()
return
}
userID = object.UserID
case "answer":
object, has, e := vs.answerRepo.GetAnswer(ctx, objectID)
if e != nil || !has {
err = errors.BadRequest(reason.AnswerNotFound).WithError(e).WithStack()
return
}
userID = object.UserID
case "comment":
object, has, e := vs.commentCommonRepo.GetComment(ctx, objectID)
if e != nil || !has {
err = errors.BadRequest(reason.CommentNotFound).WithError(e).WithStack()
return
}
userID = object.UserID
default:
err = errors.BadRequest(reason.DisallowVote).WithError(err).WithStack()
return
}
return
} | Base | 1 |
func (vs *VoteService) VoteDown(ctx context.Context, dto *schema.VoteDTO) (voteResp *schema.VoteResp, err error) {
voteResp = &schema.VoteResp{}
var objectUserID string
objectUserID, err = vs.GetObjectUserID(ctx, dto.ObjectID)
if err != nil {
return
}
// check user is voting self or not
if objectUserID == dto.UserID {
err = errors.BadRequest(reason.DisallowVoteYourSelf)
return
}
if dto.IsCancel {
return vs.voteRepo.VoteDownCancel(ctx, dto.ObjectID, dto.UserID, objectUserID)
} else {
return vs.voteRepo.VoteDown(ctx, dto.ObjectID, dto.UserID, objectUserID)
}
} | Base | 1 |
func (vs *VoteService) VoteUp(ctx context.Context, dto *schema.VoteDTO) (voteResp *schema.VoteResp, err error) {
voteResp = &schema.VoteResp{}
var objectUserID string
objectUserID, err = vs.GetObjectUserID(ctx, dto.ObjectID)
if err != nil {
return
}
// check user is voting self or not
if objectUserID == dto.UserID {
err = errors.BadRequest(reason.DisallowVoteYourSelf)
return
}
if dto.IsCancel {
return vs.voteRepo.VoteUpCancel(ctx, dto.ObjectID, dto.UserID, objectUserID)
} else {
return vs.voteRepo.VoteUp(ctx, dto.ObjectID, dto.UserID, objectUserID)
}
} | Base | 1 |
func NewVoteService(
VoteRepo VoteRepo,
uniqueIDRepo unique.UniqueIDRepo,
configService *config.ConfigService,
questionRepo questioncommon.QuestionRepo,
answerRepo answercommon.AnswerRepo,
commentCommonRepo comment_common.CommentCommonRepo,
objectService *object_info.ObjService,
) *VoteService {
return &VoteService{
voteRepo: VoteRepo,
UniqueIDRepo: uniqueIDRepo,
configService: configService,
questionRepo: questionRepo,
answerRepo: answerRepo,
commentCommonRepo: commentCommonRepo,
objectService: objectService,
}
} | Base | 1 |
func (am *AuthUserMiddleware) AdminAuth() gin.HandlerFunc {
return func(ctx *gin.Context) {
token := ExtractToken(ctx)
if len(token) == 0 {
handler.HandleResponse(ctx, errors.Unauthorized(reason.UnauthorizedError), nil)
ctx.Abort()
return
}
userInfo, err := am.authService.GetAdminUserCacheInfo(ctx, token)
if err != nil {
handler.HandleResponse(ctx, errors.Forbidden(reason.UnauthorizedError), nil)
ctx.Abort()
return
}
if userInfo != nil {
if userInfo.UserStatus == entity.UserStatusDeleted {
handler.HandleResponse(ctx, errors.Unauthorized(reason.UnauthorizedError), nil)
ctx.Abort()
return
}
ctx.Set(ctxUUIDKey, userInfo)
}
ctx.Next()
}
} | Base | 1 |
func (ar *AnswerActivityRepo) SaveAcceptAnswerActivity(ctx context.Context, op *schema.AcceptAnswerOperationInfo) (
err error) {
// pre check
noNeedToDo, err := ar.activityPreCheck(ctx, op)
if err != nil {
return err
}
if noNeedToDo {
return nil
}
ar.data.DB.ShowSQL(true)
// save activity
_, err = ar.data.DB.Transaction(func(session *xorm.Session) (result any, err error) {
session = session.Context(ctx)
userInfoMapping, err := ar.acquireUserInfo(session, op.GetUserIDs())
if err != nil {
return nil, err
}
err = ar.saveActivitiesAvailable(session, op)
if err != nil {
return nil, err
}
err = ar.changeUserRank(ctx, session, op, userInfoMapping)
if err != nil {
return nil, err
}
return nil, nil
})
if err != nil {
return errors.InternalServer(reason.DatabaseError).WithError(err).WithStack()
}
// notification
ar.sendAcceptAnswerNotification(ctx, op)
return nil
} | Base | 1 |
func (ar *AnswerActivityRepo) sendAcceptAnswerNotification(
ctx context.Context, op *schema.AcceptAnswerOperationInfo) {
for _, act := range op.Activities {
msg := &schema.NotificationMsg{
Type: schema.NotificationTypeAchievement,
ObjectID: op.AnswerObjectID,
ReceiverUserID: act.ActivityUserID,
}
if act.ActivityUserID == op.QuestionUserID {
msg.TriggerUserID = op.AnswerUserID
msg.ObjectType = constant.AnswerObjectType
} else {
msg.TriggerUserID = op.QuestionUserID
msg.ObjectType = constant.AnswerObjectType
}
if msg.TriggerUserID != msg.ReceiverUserID {
ar.notificationQueueService.Send(ctx, msg)
}
}
for _, act := range op.Activities {
msg := &schema.NotificationMsg{
ReceiverUserID: act.ActivityUserID,
Type: schema.NotificationTypeInbox,
ObjectID: op.AnswerObjectID,
}
if act.ActivityUserID != op.QuestionUserID {
msg.TriggerUserID = op.QuestionUserID
msg.ObjectType = constant.AnswerObjectType
msg.NotificationAction = constant.NotificationAcceptAnswer
ar.notificationQueueService.Send(ctx, msg)
}
}
} | Base | 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.