/// <summary>根据授权码获取访问令牌</summary>
/// <param name="code"></param>
/// <returns></returns>
public virtual String GetAccessToken(String code)
{
if (code.IsNullOrEmpty())
{
throw new ArgumentNullException(nameof(code), "未设置授权码");
}
Code = code;
var url = GetUrl(AccessUrl);
WriteLog("GetAccessToken {0}", url);
var html = Request(url);
if (html.IsNullOrEmpty())
{
return(null);
}
html = html.Trim();
if (Log != null && Log.Enable)
{
WriteLog(html);
}
var dic = GetNameValues(html);
if (dic != null)
{
if (dic.ContainsKey("access_token"))
{
AccessToken = dic["access_token"].Trim();
}
if (dic.ContainsKey("expires_in"))
{
Expire = DateTime.Now.AddSeconds(dic["expires_in"].Trim().ToInt());
}
if (dic.ContainsKey("refresh_token"))
{
RefreshToken = dic["refresh_token"].Trim();
}
// 如果响应区域包含用户信息，则增加用户地址
if (UserUrl.IsNullOrEmpty() && dic.ContainsKey("scope"))
{
var ss = dic["scope"].Trim().Split(",");
if (ss.Contains("UserInfo"))
{
UserUrl = "userinfo?access_token={token}";
LogoutUrl = "logout?client_id={key}&redirect_uri={redirect}&state={state}";
}
}
OnGetInfo(dic);
}
Items = dic;
return(html);
}
public async Task <IActionResult> PutUserUrl([FromRoute] string id, [FromBody] UserUrl userUrl)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != userUrl.UrlId)
{
return(BadRequest());
}
_context.Entry(userUrl).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!UserUrlExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <string> CreateShortUrlForUser(Guid userId, string url)
{
var isExistUser = await ShortenURlDbContext.UserUrl.FirstOrDefaultAsync(c => c.UserId == userId);
var shortUrl = createShortUrlService.MakeShortURL();
var newShortUrl = new ShortUrl()
{
ShortUrlString = shortUrl,
Url = url
};
if (isExistUser != null)
{
isExistUser.ShortUrls.Add(newShortUrl);
await ShortenURlDbContext.SaveChangesAsync();
}
else
{
var newUserUrl = new UserUrl()
{
UserId = userId
};
newUserUrl.ShortUrls.Add(newShortUrl);
ShortenURlDbContext.UserUrl.Add(newUserUrl);
await ShortenURlDbContext.SaveChangesAsync();
}
return(shortUrl);
}
protected void MyUrlsGridView_RowCommand(object sender, GridViewCommandEventArgs e)
{
var commands = new[] { "start", "stop", "remove" };
if (commands.Contains(e.CommandName))
{
var index = e.GetSelectedRowIndex() % MyUrlsGridView.PageSize;
var row = MyUrlsGridView.Rows[index];
var urlId = (row.Cells[0].Text.Trim());
var url = new UserUrl(Convert.ToInt32(urlId));
switch (e.CommandName)
{
case "start":
if (url.Status == AdvertStatus.Paused)
{
url.Activate();
}
break;
case "stop":
if (url.Status == AdvertStatus.Active)
{
url.Pause();
}
break;
case "remove":
url.Delete();
break;
}
MyUrlsGridView.DataBind();
}
}
protected void AddUrlButton_Click(object sender, EventArgs e)
{
if (Page.IsValid)
{
try
{
AppSettings.DemoCheck();
ErrorMessagePanel.Visible = SuccessMessagePanel.Visible = false;
UserUrl.Create(Member.CurrentId, UrlTextBox.Text);
SuccessMessagePanel.Visible = true;
SuccessMessage.Text = U6000.REQUESTSENTPLEASEWAIT;
}
catch (Exception ex)
{
if (ex is Exception)
{
ErrorMessagePanel.Visible = true;
ErrorMessage.Text = ex.Message;
}
else
{
ErrorLogger.Log(ex);
}
}
finally
{
ClearAll();
}
}
}
/// <summary>
/// Создание сжатой ссылки
/// </summary>
/// <param name="userUrl"><seealso cref="UserUrl"/></param>
/// <param name="userGuid">гуид пользователя</param>
/// <returns></returns>
public async Task <string> AddUserUrlAsync(UserUrl userUrl, Guid userGuid)
{
using (var context = new UrlShortenerContext())
{
if (userUrl == null || userGuid == Guid.Empty)
{
throw new NullReferenceException();
}
//есть такой пользователь в Бд?
var user = await context.Users.FirstOrDefaultAsync(x => x.UserGuid == userGuid);
var userId = user?.Id;
if (userId == null)
{
//добавляем в БД пользователя
var result = context.Users.Add(new User()
{
UserGuid = userGuid
});
userId = result.Id;
}
userUrl.UserId = (long)userId;
var newUrl = context.UserUrls.Add(userUrl);
await context.SaveChangesAsync();
return(newUrl.CompactUrl);
}
}
protected void UserUrlsCheckBoxList_Init(object sender, EventArgs e)
{
var urls = UserUrl.GetActive(Member.CurrentId);
foreach (var url in urls)
{
UserUrlsCheckBoxList.Items.Add(new ListItem(url.Url, url.Id.ToString()));
}
UserUrlsCheckBoxList.DataBind();
}
public async Task <IActionResult> PostUserUrl([FromBody] UserUrl userUrl)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_context.UserUrl.Add(userUrl);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetUserUrl", new { id = userUrl.UrlId }, userUrl));
}
public UrlDTO GetUrl(int id)
{
UserUrl userUrl = _repository.GetItem(id);
if (userUrl == null)
{
throw new ValidationException("Url not found", "");
}
return(new UrlDTO {
Id = userUrl.Id, Content = userUrl.Content, Url = userUrl.Url
});
}
public void EditUrl(UrlDTO url)
{
UserUrl userUrl = _repository.GetItem(url.Id);
if (userUrl == null)
{
throw new ValidationException("Url not found", "");
}
userUrl.Url = url.Url;
userUrl.Content = url.Content;
_repository.EditItem(userUrl);
_repository.Save();
}
public static void ChangeAllStatuses(IEnumerable <int> ids, AdvertStatus status)
{
foreach (var id in ids)
{
var url = new UserUrl(id);
if (status == AdvertStatus.Active)
{
url.Accept();
}
else if (status == AdvertStatus.Rejected)
{
url.Reject();
}
}
}
/// <summary>
/// Создание сжатой ссылки
/// </summary>
/// <param name="userUrl">Описание добавляемой ссылки<seealso cref="UserUrlData"/></param>
/// <returns></returns>
public async Task <UserUrlResult> AddUserUrlAsync(UserUrlData userUrl)
{
if (userUrl.UserGuid == null || userUrl.UserGuid == Guid.Empty)
{
userUrl.UserGuid = Guid.NewGuid();
}
var data = new UserUrl
{
CreateOn = DateTime.Now,
CompactUrl = userUrl.CompactUrl,
NumberOfViews = 0,
OriginUrl = userUrl.OriginUrl
};
var compactUrl = await _urlShortenerRep.AddUserUrlAsync(data, (Guid)userUrl.UserGuid);
return(new UserUrlResult {
CompactUrl = compactUrl, UserGuid = (Guid)userUrl.UserGuid
});
}
protected void CreateOfferWallView_Activate(object sender, EventArgs e)
{
bool packsConfigured = PTCOfferWall.ArePacksConfigured();
bool userHasActiveUrls = UserUrl.UserHasActive(Member.CurrentId);
CreateOfferWallsPlaceHolder.Visible = packsConfigured && userHasActiveUrls;
if (!CreateOfferWallsPlaceHolder.Visible)
{
NewOfferWallUnavailable.Visible = true;
NewOfferWallUnavailable.HeaderText = U6000.NEWADVERTUNAVAILABLEHEADER;
string reason = !packsConfigured ? U6000.NEWADVERTUNAVAILABLEREASON : U6002.PLEASEADDURLSFIRST;
NewOfferWallUnavailable.Reason = reason;
}
else
{
NewOfferWallUnavailable.Visible = false;
}
}
public static void Create(int userId, string url)
{
var userUrl = Get(userId, url);
if (userUrl != null)
{
if (userUrl.Status == AdvertStatus.Rejected)
{
throw new MsgException(U6002.THISURLHASBEENREJECTED);
}
else
{
userUrl.Status = AdvertStatus.WaitingForAcceptance;
}
}
else
{
userUrl = new UserUrl(userId, url);
}
userUrl.Save();
}
private void buttonOk_Click(object sender, EventArgs e)
{
try
{
if (!String.IsNullOrEmpty(richTextBoxUrls.Text))
{
string[] splits = richTextBoxUrls.Text.Split(new string[] { "\n" }, StringSplitOptions.RemoveEmptyEntries);
using (BotContext context = new BotContext())
{
User user = context.Users.FirstOrDefault(x => x.Id == userId);
foreach (string split in splits)
{
UserUrl userUrl = user.UserUrls.FirstOrDefault(x => x.Value == split);
if (userUrl == null)
{
userUrl = new UserUrl();
userUrl.User = user;
userUrl.Value = split;
user.UserUrls.Add(userUrl);
}
}
context.SaveChanges();
Singleton.Main.RefreshUrls(user.UserUrls.ToList());
this.Close();
}
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Ошибка", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
/// <summary>企业内部应用获取用户信息</summary>
/// <param name="access_token"></param>
/// <param name="userid">员工id</param>
/// <returns></returns>
public IDictionary <String, Object> GetUserInfo(String access_token, String userid)
{
var url = UserUrl.Replace("{token}", access_token).Replace("{userid}", userid);
var http = CreateClient();
var buf = Task.Run(() => http.GetAsync <Byte[]>(url)).Result;
var str = buf.ToStr();
var js = new JsonParser(str).Decode() as IDictionary <String, Object>;
UserName = js["name"] + "";
NickName = js["nick"] + "";
Avatar = js["avatar"] + "";
Mail = js["email"] + "";
Mobile = js["mobile"] + "";
Code = js["jobnumber"] + "";
// 合并字典
var dic = Items;
if (dic == null)
{
Items = js.ToDictionary(e => e.Key, e => e.Value as String);
}
else
{
foreach (var item in js)
{
if (!dic.ContainsKey(item.Key))
{
dic[item.Key] = item.Value as String;
}
}
}
return(js);
}
/// <summary> /// Get user information with default mode set by user. /// </summary> public async Task <(ApiStatus, UserV2)> GetUserAsync(int osuId) => await GetAsync <UserV2>(UserUrl(osuId), _auth);
public async Task <IActionResult> Start(UserUrlModel model)
{
using (var client = new HttpClient())
{
// Assuming the API is in the same web application.
string baseUrl = $"{this.Request.Scheme}://{this.Request.Host}{this.Request.PathBase}";
//Check if the user is already available in db
client.BaseAddress = new Uri(baseUrl);
var responseMessage = client.GetAsync("/api/Users");
responseMessage.Wait();
User user = null;
var result = responseMessage.Result;
if (result.IsSuccessStatusCode)
{
var stream = await result.Content.ReadAsStreamAsync();
using (JsonReader jsonReader = new JsonTextReader(new System.IO.StreamReader(stream)))
{
var serializer = new JsonSerializer();
var users = serializer.Deserialize <IEnumerable <User> >(jsonReader);
user = users.Where(t => t.Email == model.Email).FirstOrDefault();
}
}
if (user == null)
{
user = new User()
{
UserId = Guid.NewGuid().ToString(),
Email = model.Email
};
var postTask = client.PostAsJsonAsync <User>("/api/Users", user);
postTask.Wait();
if (!postTask.Result.IsSuccessStatusCode)
{
return(View("Error"));
}
/*else
* {
* var stream = await result.Content.ReadAsStreamAsync();
* using (JsonReader jsonReader = new JsonTextReader(new System.IO.StreamReader(stream)))
* {
* var serializer = new JsonSerializer();
* user = serializer.Deserialize<User>(jsonReader);
* }
* }*/
}
UserUrl userUrl = new UserUrl
{
UrlId = Guid.NewGuid().ToString(),
UserId = user.UserId,
ActualUrl = model.ActualUrl,
Description = model.Description
};
userUrl.ShortUrl = $"{this.Request.Scheme}://{this.Request.Host}{this.Request.PathBase}/Home/DynamicUrl?id=" + userUrl.UrlId;
var usersUrlTask = client.PostAsJsonAsync <UserUrl>("/api/UserUrls", userUrl);
usersUrlTask.Wait();
if (usersUrlTask.Result.IsSuccessStatusCode)
{
return(View("Added",
new UserUrlModel {
UrlId = userUrl.UrlId, Email = user.Email, ShortUrl = userUrl.ShortUrl, ActualUrl = userUrl.ActualUrl, Description = userUrl.Description
}));
}
}
return(View());
}
