private static byte[] Worker(WorkerType workerType, byte[] data, byte[] key, byte[] iv)
{
if (data == null)
{
throw new ArgumentNullException(nameof(data));
}
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
if (iv == null)
{
throw new ArgumentNullException(nameof(iv));
}
using (var aes = Aes.Create())
{
aes.BlockSize = iv.Length * 8;
aes.KeySize = key.Length * 8;
aes.Mode = CipherMode.CBC;
aes.Padding = PaddingMode.PKCS7;
using (var ms = new MemoryStream())
using (var transformer = (workerType == WorkerType.Encrypt) ? aes.CreateEncryptor(key, iv) : aes.CreateDecryptor(key, iv))
using (var cs = new CryptoStream(ms, transformer, CryptoStreamMode.Write))
{
cs.Write(data, 0, data.Length);
cs.FlushFinalBlock();
return(ms.ToArray());
}
}
}
public Worker CreateWorker(WorkerType type)
{
switch (type)
{
case WorkerType.WORKER1:
return(CreateWorkerFromPrefab(PrefabManager.instance.worker1Fab));
case WorkerType.WORKER2:
return(CreateWorkerFromPrefab(PrefabManager.instance.worker2Fab));
case WorkerType.WORKER3:
return(CreateWorkerFromPrefab(PrefabManager.instance.worker3Fab));
case WorkerType.WORKER4:
return(CreateWorkerFromPrefab(PrefabManager.instance.worker4Fab));
case WorkerType.WORKER5:
return(CreateWorkerFromPrefab(PrefabManager.instance.worker5Fab));
case WorkerType.WORKER6:
return(CreateWorkerFromPrefab(PrefabManager.instance.worker6Fab));
case WorkerType.WORKER7:
return(CreateWorkerFromPrefab(PrefabManager.instance.worker7Fab));
case WorkerType.WORKER8:
return(CreateWorkerFromPrefab(PrefabManager.instance.worker8Fab));
case WorkerType.WORKER9:
return(CreateWorkerFromPrefab(PrefabManager.instance.worker9Fab));
}
return(null);
}
private static LogResponse Get(string stack, WorkerType workerType, string startTime = null, string endTime = null, string timeGrain = null)
{
DateTime startTimeUtc, endTimeUtc;
TimeSpan timeGrainTimeSpan;
string errorMessage;
if (!PrepareStartEndTimeUtc(startTime, endTime, timeGrain, out startTimeUtc, out endTimeUtc, out timeGrainTimeSpan, out errorMessage))
{
throw new WebException(HttpStatusCode.BadRequest.ToString() + ": " + errorMessage);
}
LogParserParameters p = new LogParserParameters();
p.StartTime = startTimeUtc;
p.EndTime = endTimeUtc;
p.TimeGrain = timeGrainTimeSpan;
p.WorkerType = workerType;
Parser parser = ParserFactory.GetParser(stack);
if (parser == null)
{
throw new WebException("Stack " + stack + " has no log parser implimintation");
}
return(parser.GetHistogramAsync(p).Result);
}
public async Task <IActionResult> PutWorkerType(Guid id, WorkerType workerType)
{
if (id != workerType.WorkerTypeId)
{
return(BadRequest());
}
_context.Entry(workerType).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!WorkerTypeExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public Manager(string name, int employeeID, WorkerType workerType)
{
Subordinates = new List <IWorker>();
Name = name;
WorkerID = employeeID;
WorkerType = workerType;
}
public Worker RequestWorker(Building building, WorkerType workerType = WorkerType.Builder)
{
if (workerType == WorkerType.Builder)
{
if (isWorkerAvailable())
{
return(currentWorkers.Where(w => w.GetComponent <Worker>().Status == WorkerStatus.Free).OrderBy(w => Vector3.Distance(w.transform.position, building.Waypoint.transform.position)).Select(w => w.GetComponent <Worker>()).FirstOrDefault());
}
else if (currentWorkers.Count < maxWorkers)
{
var worker = Worker.Create(this, GetNearestAdminBuilding(building.transform.position), workerType);
RegisterWorker(worker);
worker.WorkerType = workerType;
return(worker);
}
}
else
{
var worker = Worker.Create(this, GetNearestAdminBuilding(building.transform.position), workerType);
worker.name = workerType.ToString();
worker.WorkerType = workerType;
return(worker);
}
return(null);
}
public void SetType(WorkerType workerType)
{
this.workerType = workerType;
// Set sprite
SpriteRenderer spriteRenderer = GetComponent <SpriteRenderer>();
switch (workerType)
{
case WorkerType.Heart:
Heart heart = Instantiate(heartPrefab);
heart.building = this;
heart.transform.position = new Vector2(transform.position.x, transform.position.y + 0.5f);
spriteRenderer.color = Color.magenta;
break;
case WorkerType.Defense:
spriteRenderer.color = Color.cyan;
Turret turret = Instantiate(turretPrefab);
turret.transform.position = new Vector2(transform.position.x, transform.position.y + 0.5f);
break;
case WorkerType.Nursery:
Worker worker = Instantiate(workerPrefab);
worker.GetComponent <Rigidbody2D>().gravityScale = 0;
worker.transform.localScale = new Vector3(1, 1, 1);
worker.building = this;
worker.transform.position = new Vector2(transform.position.x, transform.position.y + 0.5f);
spriteRenderer.color = new Color(0.88f, 0.53f, 0);
break;
}
}
private static WorkerType GetDeflaterType()
{
// Let's not worry about race conditions:
// Yes, we risk initialising the singleton multiple times.
// However, initialising the singleton multiple times has no bad consequences, and is fairly cheap.
if (WorkerType.Unknown != deflaterType)
{
return(deflaterType);
}
#if !SILVERLIGHT // Do this on Desktop. CLRConfig doesn't exist on CoreSys nor Silverlight.
// CLRConfig is internal in mscorlib and is a friend
if (System.CLRConfig.CheckLegacyManagedDeflateStream())
{
return(deflaterType = WorkerType.Managed);
}
#endif
#if !SILVERLIGHT || FEATURE_NETCORE // Only skip this for Silverlight, which doesn't ship ZLib.
if (!CompatibilitySwitches.IsNetFx45LegacyManagedDeflateStream)
{
return(deflaterType = WorkerType.ZLib);
}
#endif
return(deflaterType = WorkerType.Managed);
}
private void btnEncrypt_Click(object sender, EventArgs e)
{
if (bw.IsBusy != true)
{
workerType = WorkerType.Encryption;
rtbSource.Enabled = false;
tbPassword.Enabled = false;
nudEncryptTimes.Enabled = false;
cbAutoDecrypt.Enabled = false;
cbRandomAlgorithm.Enabled = false;
labDragDropHints.AllowDrop = false;
_cbRandomAlgorithmChecked = cbRandomAlgorithm.Checked;
_cbEncryptionAlgorithmSelectedIndex = cbEncryptionAlgorithm.SelectedIndex;
_rtbSourceText = rtbSource.Text;
_tbPasswordText = tbPassword.Text;
_nudEncryptTimesValue = (int)nudEncryptTimes.Value;
pbInfoTotal.Maximum = (int)nudEncryptTimes.Value;
pbInfoTotal.Value = 0;
pbInfoTotal.Enabled = true;
pbInfoSession.Value = 0;
pbInfoSession.Enabled = true;
labLayerDecrypted.Visible = false;
btnStop.Enabled = true;
bw.RunWorkerAsync();
}
}
private static IInflater CreateInflater(IFileFormatReader reader = null)
{
// The deflator type (zlib or managed) is normally determined by s_deflatorType,
// which is initialized by the provider based on what's available on the system.
// But for testing purposes, we sometimes want to override this, forcing
// compression/decompression to use a particular type.
WorkerType deflatorType = s_deflaterType;
#if DEBUG
if (s_forcedTestingDeflaterType != WorkerType.Unknown)
{
deflatorType = s_forcedTestingDeflaterType;
}
#endif
if (deflatorType == WorkerType.ZLib)
{
// Rather than reading raw data and using a FormatReader to interpret
// headers/footers manually, we instead set the zlib stream to parse
// that information for us.
if (reader == null)
{
return(new InflaterZlib(ZLibNative.Deflate_DefaultWindowBits));
}
else
{
Debug.Assert(reader.ZLibWindowSize == 47, "A GZip reader must be designated with ZLibWindowSize == 47. Other header formats aren't supported by ZLib.");
return(new InflaterZlib(reader.ZLibWindowSize));
}
}
else
{
return(new InflaterManaged(reader));
}
}
public void DisplayWorker(Worker worker, ShopManager mgr, int num)
{
type = worker.type;
worker.transform.position = transform.Find("WorkerSlot").position;
transform.Find("Name").GetComponent <Text>().text = worker.workerName;
GetComponentInChildren <Button>().onClick.AddListener(delegate { mgr.GoToNextYear(num); });
}
public async Task <ActionResult <WorkerType> > PostWorkerType(WorkerType workerType)
{
_context.WorkerTypes.Add(workerType);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetWorkerType", new { id = workerType.WorkerTypeId }, workerType));
}
void worker_DoWork(object sender, DoWorkEventArgs e)
{
WorkerType type = (WorkerType)Enum.ToObject(typeof(WorkerType), e.Argument);
var dict = new Dictionary <string, object>();
dict["type"] = type;
e.Result = dict;
switch (type)
{
case WorkerType.Gen:
{
var maze = new Maze(display.Size);
ShowStatus("正在生成地图");
maze.GenerateMaze();
MazeSettings.CurrentMaze = maze;
}
break;
case WorkerType.Solve:
{
var maze = MazeSettings.CurrentMaze;
if (maze == null)
{
throw new Exception("地图未生成");
}
ShowStatus("正在搜索路径");
dict["result"] = maze.SolveMaze();
}
break;
}
}
public uint Count(WorkerType type)
{
switch (type)
{
case WorkerType.archaeologist:
return((uint)archaelogists.Count);
case WorkerType.geologist:
return((uint)geologists.Count);
case WorkerType.excavator:
return((uint)excavators.Count);
case WorkerType.cook:
return((uint)cooks.Count);
case WorkerType.physician:
return((uint)physicians.Count);
case WorkerType.generic:
return(0);
default:
return(0);
}
}
WorkerType workerType; // Artist, AudioDesigner, or Programmer
#endregion Fields
#region Constructors
public Worker(GameObject gameObject, WorkerType workerType, int gender)
{
this.gameObject = gameObject;
this.charObject = gameObject.transform.Find("Character").gameObject;
this.anim = charObject.GetComponent<Animator>();
this.workerType = workerType;
this.startingPos = gameObject.transform.position;
this.gender = gender;
roadblockParticle = gameObject.GetComponentInChildren<ParticleSystem>();
if(roadblockParticle != null) roadblockParticle.Stop();
starfloat = Random.Range(0f,5f);
// Get 3 Random Personal Badges
List<string> badgeNames = new List<string>();
for(int i = 0; i < 3; i++)
{
PersonalBadge badge = new PersonalBadge(Random.Range(0,5));
if(!badgeNames.Contains(badge.name))
{
badges.Add(badge);
badgeNames.Add(badge.name);
} else i--;
}
// Get Renderers
GetRenderers();
SetToNormal();
}
public Worker(string name, WorkerType type, object rWorker)
{
Name = name;
Type = type;
RealWorker = rWorker;
Running = false;
}
public void SetWorker <U>(WorkerType workerType, StdSharedPtr <U> worker, bool workerOnNewThread = true)
where U : Worker <T>
{
this.ThrowIfDisposed();
NativeMethods.op_wrapper_setWorker(this._DataType, this.NativePtr, workerType, worker.NativePtr, workerOnNewThread);
}
private async Task <LogResponse> Get(string stack, WorkerType workerType, string startTime = null, string endTime = null, string timeGrain = null)
{
Util.WriteLog("Get(string stack, WorkerType workerType, string startTime = null, string endTime = null, string timeGrain = null)");
DateTime startTimeUtc, endTimeUtc;
TimeSpan timeGrainTimeSpan;
string errorMessage;
if (!PrepareStartEndTimeUtc(startTime, endTime, timeGrain, out startTimeUtc, out endTimeUtc, out timeGrainTimeSpan, out errorMessage))
{
if (Request == null)
{
throw new WebException(HttpStatusCode.BadRequest.ToString() + ": " + errorMessage);
}
throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.BadRequest, errorMessage));
}
LogParserParameters p = new LogParserParameters();
p.StartTime = startTimeUtc;
p.EndTime = endTimeUtc;
p.TimeGrain = timeGrainTimeSpan;
p.WorkerType = workerType;
var parser = workerType == WorkerType.Windows ? ParserFactory.GetParser(stack) : ParserFactory.GetLinuxParser(stack);
Util.WriteLog("Parser type: " + parser.GetType().Name);
if (parser == null)
{
throw new WebException("Stack " + stack + " has no log parser implimintation");
}
return(await parser.GetHistogramAsync(p));
}
public Worker(WorkerType gpuType, int gpuID, int platformID)
{
type = gpuType;
workerDeviceID = gpuID;
workerPlatformID = platformID;
workerCommPort = 13500 + (int)gpuType + gpuID * platformID;
}
private static DocumentWorker CreateWorker()
{
DocumentWorker docWorker;
WorkerType worker = DefineWorker();
int Key = 0;
if (worker != WorkerType.Base)
{
Key = DefineKey();
}
if ((worker == WorkerType.Pro) && (Key != 0)) // Pro worker with defined key
{
docWorker = new ProDocumentWorker(Key);
}
else if ((worker == WorkerType.Expert) && (Key != 0)) // Expert worker with defined key
{
docWorker = new ExpertDocumentWorker(Key);
}
else
{
docWorker = new DocumentWorker(); // Base worker definition
}
return(docWorker);
}
public void setJob(WorkerType workerType, WorkerTask workerTask)
{
if (workerType == WorkerType.UNCHANGED)
{
}
else if (workerType == WorkerType.UNASSIGNED)
{
anim.SetBool("Chopper", false);
anim.SetBool("Soldier", false);
}
else
{
givenJob = workerType;
if (givenJob == WorkerType.LumberJack)
{
O_actiontime = animas[0].length;
wfs = new WaitForSeconds(animas[0].length);
anim.SetBool("Chopper", true);
}
else if (givenJob == WorkerType.Soldier)
{
O_actiontime = animas[1].length;
wfs = new WaitForSeconds(animas[1].length);
anim.SetBool("Soldier", true);
}
}
task = workerTask;
}
public async Task <IActionResult> Edit(int id, [Bind("WorkerTypeId,WorkerTypeName,WorkerTypeCode,ArrangeOrder")] WorkerType workerType)
{
if (id != workerType.WorkerTypeId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(workerType);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!WorkerTypeExists(workerType.WorkerTypeId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(workerType));
}
private void AddWorkerType()
{
using (ApplicationDbContext context = new ApplicationDbContext())
{
if (!context.WorkerType.Any())
{
WorkerType worker1 = new WorkerType();
WorkerType worker2 = new WorkerType();
WorkerType worker3 = new WorkerType();
WorkerType worker4 = new WorkerType();
worker1.Id = Guid.NewGuid();
worker2.Id = Guid.NewGuid();
worker3.Id = Guid.NewGuid();
worker4.Id = Guid.NewGuid();
worker1.Type = "Foreman";
worker2.Type = "General Worker";
worker3.Type = "Semi-skilled Worker";
worker4.Type = "Skilled Worker";
worker1.Slug = "foreman";
worker2.Slug = "generalworker";
worker3.Slug = "semiskilledworker";
worker4.Slug = "skilledworker";
context.WorkerType.Add(worker1);
context.WorkerType.Add(worker2);
context.WorkerType.Add(worker3);
context.WorkerType.Add(worker4);
context.SaveChanges();
}
}
}
public Worker(string wId, string wName, string wPsw, WorkerType wType)
{
id = wId;
name = wName;
password = wPsw;
type = wType;
}
private static IDeflater CreateDeflater(CompressionLevel?compressionLevel)
{
// The deflator type (zlib or managed) is normally determined by s_deflatorType,
// which is initialized by the provider based on what's available on the system.
// But for testing purposes, we sometimes want to override this, forcing
// compression/decompression to use a particular type.
WorkerType deflatorType = s_deflaterType;
#if DEBUG
if (s_forcedTestingDeflaterType != WorkerType.Unknown)
{
deflatorType = s_forcedTestingDeflaterType;
}
#endif
if (deflatorType == WorkerType.ZLib)
{
return(compressionLevel.HasValue ?
new DeflaterZLib(compressionLevel.Value) :
new DeflaterZLib());
}
else
{
Debug.Assert(deflatorType == WorkerType.Managed);
return(new DeflaterManaged());
}
}
public TableWorker(string connectionString, WorkerType type)
{
CloudTableClient client = CloudStorageAccount.Parse(connectionString).CreateCloudTableClient();
this.table = client.GetTableReference(TableWorker.TableName);
this.type = type;
}
/*private void CreateWorker(WorkerType type)
{
}*/
// ------------------------ Worker List Management -------------------------------
public static Worker AddWorker(GameObject newWorker, WorkerType type, int gender)
{
Worker worker = null;
worker = new Worker(newWorker, type, gender);
workers.Add(worker);
return worker;
}
public static void DestroyAndRecreateThread(AtlasServerManager form1, WorkerType ThreadIndex)
{
if (Workers[(int)ThreadIndex] != null)
{
Workers[(int)ThreadIndex].Abort();
}
AddWorker(ThreadIndex, new ParameterizedThreadStart(ArkServerStatusUpdate.UpdateStatus), form1);
}
public override void Show(Building callingBuilding, WorkerType workerType = WorkerType.generic)
{
base.Show(callingBuilding, WorkerType.archaeologist);
//hq = callingBuilding.GetComponent<HQ>();
// UpdateButtons();
// UpdateStats();
}
public float GetScore(WorkerType type)
{
if (Key != null)
{
return(Function.Round(Key.Score * Key.Coefficient[type] / GetCoefficientTotal() * Quality, 2));
}
return(0);
}
public ActionResult DeleteConfirmed(int id)
{
WorkerType workerType = db.WorkerTypes.Find(id);
db.WorkerTypes.Remove(workerType);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public IMyWorker CreateInstance(WorkerType workerType)
{
if (workerType == WorkerType.A)
{
return(this.container.GetInstance <IWorkerA>());
}
return(this.container.GetInstance <IWorkerB>());
}
void Init(WorkerType type)
{
if (worker.IsBusy)
{
MessageBox.Show(this, "任务正在运行！", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
else
{
worker.RunWorkerAsync(type);
}
}
private void GetTimeline(WorkerType workerType, int fromPage = 1, int toPage = 0, string tabName = "")
{
if (!MyCommon.IsNetworkAvailable())
{
return;
}
if (_lastTimeWork == null)
{
_lastTimeWork = new Dictionary<WorkerType, DateTime>();
}
// 非同期実行引数設定
if (!_lastTimeWork.ContainsKey(workerType))
{
_lastTimeWork.Add(workerType, new DateTime());
}
double period = DateTime.Now.Subtract(_lastTimeWork[workerType]).TotalSeconds;
if (period > 1 || period < -1)
{
_lastTimeWork[workerType] = DateTime.Now;
RunAsync(new GetWorkerArg { Page = fromPage, EndPage = toPage, WorkerType = workerType, TabName = tabName });
}
}
private bool ResetWorkerTimer(ref int counter, int initailValue, WorkerType worker, bool reset, bool usflag = false)
{
if (reset || (counter < 1 && initailValue > 0))
{
Interlocked.Exchange(ref counter, initailValue);
if (!usflag && !reset)
{
GetTimeline(worker);
}
return false;
}
return false;
}
private void AdjustProductivityRates(WorkerType type, float amount)
{
switch(type)
{
case WorkerType.Artist:
artProductivity += amount;
break;
case WorkerType.Programmer:
programmingProductivity += amount;
break;
case WorkerType.AudioDesigner:
soundProductivity += amount;
break;
}
totalProductivity += amount;
}
private static WorkerType GetDeflaterType() {
// Let's not worry about race conditions:
// Yes, we risk initialising the singleton multiple times.
// However, initialising the singleton multiple times has no bad consequences, and is fairly cheap.
if (WorkerType.Unknown != deflaterType)
return deflaterType;
#if !SILVERLIGHT // Do this on Desktop. CLRConfig doesn't exist on CoreSys nor Silverlight.
// CLRConfig is internal in mscorlib and is a friend
if (System.CLRConfig.CheckLegacyManagedDeflateStream())
return (deflaterType = WorkerType.Managed);
#endif
#if !SILVERLIGHT || FEATURE_NETCORE // Only skip this for Silverlight, which doesn't ship ZLib.
if (!CompatibilitySwitches.IsNetFx45LegacyManagedDeflateStream)
return (deflaterType = WorkerType.ZLib);
#endif
return (deflaterType = WorkerType.Managed);
}
public Task(WorkerType engine, int transactionId)
{
this.Engine = engine;
this.TransactionId = transactionId;
}
private void WorkOnCurrentTask(WorkerType type, float productivity)
{
if(currentTask == null) return;
float workamount = productivity * WORK_RATE * Time.deltaTime;
currentTask.WorkOn(type, workamount);
AdjustProductivityRates(type, workamount);
}
/////////////////////////// WORK ON //////////////////////////////
public void WorkOn(WorkerType type, float amount)
{
switch(type)
{
case WorkerType.Artist:
art += amount;
break;
case WorkerType.Programmer:
programming += amount;
break;
case WorkerType.AudioDesigner:
sound += amount;
break;
}
if(programming > programmingReq) programming = programmingReq;
if(art > artReq) art = artReq;
if(sound > soundReq) sound = soundReq;
}
public Task(WorkerType engine, int transactionId)
{
_engine = engine;
_transactionId = transactionId;
}
public string GetDirectMessageApi(bool read, WorkerType workerType, bool more)
{
if (MyCommon.IsEnding)
{
return string.Empty;
}
if (AccountState != AccountState.Valid)
{
return string.Empty;
}
if (MyCommon.TwitterApiInfo.AccessLevel != ApiAccessLevel.None)
{
if (!MyCommon.TwitterApiInfo.IsDirectMessagePermission)
{
return "Auth Err:try to re-authorization.";
}
}
HttpStatusCode res;
string content = string.Empty;
try
{
if (workerType == WorkerType.DirectMessegeRcv)
{
res = more ?
_twitterConnection.DirectMessages(20, _minDirectmessage, 0, ref content) :
_twitterConnection.DirectMessages(20, 0, 0, ref content);
}
else
{
res = more ?
_twitterConnection.DirectMessagesSent(20, _minDirectmessageSent, 0, ref content) :
_twitterConnection.DirectMessagesSent(20, 0, 0, ref content);
}
}
catch (Exception ex)
{
return "Err:" + ex.Message;
}
switch (res)
{
case HttpStatusCode.OK:
AccountState = AccountState.Valid;
break;
case HttpStatusCode.Unauthorized:
AccountState = AccountState.Invalid;
return R.Unauthorized;
case HttpStatusCode.BadRequest:
return "Err:API Limits?";
default:
return string.Format("Err:{0}({1})", res, MethodBase.GetCurrentMethod().Name);
}
return CreateDirectMessagesFromJson(content, workerType, read);
}
// TODO: clean arguments
private string CreatePostsFromJson(string content, WorkerType workerType, TabClass tab, bool read, int count, ref long minimumId)
{
List<Status> items;
try
{
items = D.CreateDataFromJson<List<Status>>(content);
}
catch (SerializationException ex)
{
MyCommon.TraceOut(ex.Message + Environment.NewLine + content);
return "Json Parse Error(DataContractJsonSerializer)";
}
catch (Exception ex)
{
MyCommon.TraceOut(ex, MethodBase.GetCurrentMethod().Name + " " + content);
return "Invalid Json!";
}
foreach (var status in items)
{
PostClass post = CreatePostsFromStatusData(status);
if (post == null)
{
continue;
}
if (minimumId > post.StatusId)
{
minimumId = post.StatusId;
}
// 二重取得回避
lock (_lockObj)
{
if (tab == null)
{
if (TabInformations.Instance.ContainsKey(post.StatusId))
{
continue;
}
}
else
{
if (TabInformations.Instance.ContainsKey(post.StatusId, tab.TabName))
{
continue;
}
}
}
// RT禁止ユーザーによるもの
if (post.IsRetweeted && _noRetweetIds.Contains(post.RetweetedByUserId))
{
continue;
}
post.IsRead = read || post.IsMe && ReadOwnPost;
if (tab != null)
{
post.RelTabName = tab.TabName;
}
// 非同期アイコン取得＆StatusDictionaryに追加
TabInformations.Instance.AddPost(post);
}
return string.Empty;
}
private string CreateDirectMessagesFromJson(string content, WorkerType workerType, bool read)
{
List<Directmessage> item;
try
{
item = workerType == WorkerType.UserStream ?
D.CreateDataFromJson<List<DirectmessageEvent>>(content).Select(dat => dat.Directmessage).ToList() :
D.CreateDataFromJson<List<Directmessage>>(content);
}
catch (SerializationException ex)
{
MyCommon.TraceOut(ex.Message + Environment.NewLine + content);
return "Json Parse Error(DataContractJsonSerializer)";
}
catch (Exception ex)
{
MyCommon.TraceOut(ex, MethodBase.GetCurrentMethod().Name + " " + content);
return "Invalid Json!";
}
foreach (var message in item)
{
var post = new PostClass();
try
{
post.StatusId = message.Id;
if (workerType != WorkerType.UserStream)
{
if (workerType == WorkerType.DirectMessegeRcv)
{
if (_minDirectmessage > post.StatusId)
{
_minDirectmessage = post.StatusId;
}
}
else
{
if (_minDirectmessageSent > post.StatusId)
{
_minDirectmessageSent = post.StatusId;
}
}
}
// 二重取得回避
lock (_lockObj)
{
if (TabInformations.Instance.GetTabByType(TabUsageType.DirectMessage).Contains(post.StatusId))
{
continue;
}
}
post.CreatedAt = MyCommon.DateTimeParse(message.CreatedAt);
// 本文
post.TextFromApi = message.Text;
// HTMLに整形
post.Text = CreateHtmlAnchor(post.TextFromApi, post.ReplyToList, post.Media);
post.TextFromApi = HttpUtility.HtmlDecode(post.TextFromApi);
post.TextFromApi = post.TextFromApi.Replace("<3", "♡");
post.IsFav = false;
// 以下、ユーザー情報
User user;
if (workerType == WorkerType.UserStream)
{
if (_twitterConnection.AuthenticatedUsername.Equals(message.Recipient.ScreenName, StringComparison.CurrentCultureIgnoreCase))
{
user = message.Sender;
post.IsMe = false;
post.IsOwl = true;
}
else
{
user = message.Recipient;
post.IsMe = true;
post.IsOwl = false;
}
}
else
{
if (workerType == WorkerType.DirectMessegeRcv)
{
user = message.Sender;
post.IsMe = false;
post.IsOwl = true;
}
else
{
user = message.Recipient;
post.IsMe = true;
post.IsOwl = false;
}
}
post.UserId = user.Id;
post.ScreenName = user.ScreenName;
post.Nickname = user.Name.Trim();
post.ImageUrl = user.ProfileImageUrl;
post.IsProtect = user.Protected;
}
catch (Exception ex)
{
MyCommon.TraceOut(ex, MethodBase.GetCurrentMethod().Name + " " + content);
MessageBox.Show("Parse Error(CreateDirectMessagesFromJson)");
continue;
}
post.IsRead = read || post.IsMe && !read && ReadOwnPost;
post.IsReply = false;
post.IsExcludeReply = false;
post.IsDm = true;
TabInformations.Instance.AddPost(post);
}
return string.Empty;
}
public string GetTimelineApi(bool read, WorkerType workerType, bool more, bool startup)
{
if (AccountState != AccountState.Valid)
{
return string.Empty;
}
if (MyCommon.IsEnding)
{
return string.Empty;
}
HttpStatusCode res;
string content = string.Empty;
int count = Configs.Instance.CountApi;
if (workerType == WorkerType.Reply)
{
count = Configs.Instance.CountApiReply;
}
if (Configs.Instance.UseAdditionalCount)
{
if (more && Configs.Instance.MoreCountApi != 0)
{
count = Configs.Instance.MoreCountApi;
}
else if (startup && Configs.Instance.FirstCountApi != 0 && workerType == WorkerType.Timeline)
{
count = Configs.Instance.FirstCountApi;
}
}
try
{
res = workerType == WorkerType.Timeline ?
_twitterConnection.HomeTimeline(count, more ? _minHomeTimeline : 0, 0, ref content) :
_twitterConnection.Mentions(count, more ? _minMentions : 0, 0, ref content);
}
catch (Exception ex)
{
return "Err:" + ex.Message;
}
switch (res)
{
case HttpStatusCode.OK:
AccountState = AccountState.Valid;
break;
case HttpStatusCode.Unauthorized:
AccountState = AccountState.Invalid;
return R.Unauthorized;
case HttpStatusCode.BadRequest:
return "Err:API Limits?";
default:
return string.Format("Err:{0}({1})", res, MethodBase.GetCurrentMethod().Name);
}
return workerType == WorkerType.Timeline ?
CreatePostsFromJson(content, workerType, null, read, count, ref _minHomeTimeline) :
CreatePostsFromJson(content, workerType, null, read, count, ref _minMentions);
}
public string GetFavoritesApi(bool read, WorkerType workerType, bool more)
{
if (AccountState != AccountState.Valid)
{
return string.Empty;
}
if (MyCommon.IsEnding)
{
return string.Empty;
}
HttpStatusCode res;
string content = string.Empty;
int count = Configs.Instance.CountApi;
if (Configs.Instance.UseAdditionalCount && Configs.Instance.FavoritesCountApi != 0)
{
count = Configs.Instance.FavoritesCountApi;
}
// 前ページ取得の場合はページカウンタをインクリメント、それ以外の場合はページカウンタリセット
if (more)
{
_prevFavPage += 1;
}
else
{
_prevFavPage = 1;
}
try
{
res = _twitterConnection.Favorites(count, _prevFavPage, ref content);
}
catch (Exception ex)
{
return string.Format("Err:{0}({1})", ex.Message, MethodBase.GetCurrentMethod().Name);
}
switch (res)
{
case HttpStatusCode.OK:
AccountState = AccountState.Valid;
break;
case HttpStatusCode.Unauthorized:
AccountState = AccountState.Invalid;
return R.Unauthorized;
case HttpStatusCode.BadRequest:
return "Err:API Limits?";
default:
return string.Format("Err:{0}({1})", res, MethodBase.GetCurrentMethod().Name);
}
List<Status> item;
try
{
item = D.CreateDataFromJson<List<Status>>(content);
}
catch (SerializationException ex)
{
MyCommon.TraceOut(ex.Message + Environment.NewLine + content);
return "Json Parse Error(DataContractJsonSerializer)";
}
catch (Exception ex)
{
MyCommon.TraceOut(ex, MethodBase.GetCurrentMethod().Name + " " + content);
return "Invalid Json!";
}
foreach (var status in item)
{
var post = new PostClass();
try
{
post.StatusId = status.Id;
// 二重取得回避
lock (_lockObj)
{
if (TabInformations.Instance.GetTabByType(TabUsageType.Favorites).Contains(post.StatusId))
{
continue;
}
}
// Retweet判定
Entities entities;
if (status.RetweetedStatus != null)
{
var retweeted = status.RetweetedStatus;
post.CreatedAt = MyCommon.DateTimeParse(retweeted.CreatedAt);
// Id
post.RetweetedId = post.StatusId;
// 本文
post.TextFromApi = retweeted.Text;
entities = retweeted.Entities;
// Source取得（htmlの場合は、中身を取り出し）
post.Source = retweeted.Source;
// Reply先
{
long t;
long.TryParse(retweeted.InReplyToStatusId, out t);
post.InReplyToStatusId = t;
}
post.InReplyToUser = retweeted.InReplyToScreenName;
{
long t;
long.TryParse(retweeted.InReplyToUserId, out t);
post.InReplyToUserId = t;
}
post.IsFav = true;
// 以下、ユーザー情報
var user = retweeted.User;
post.UserId = user.Id;
post.ScreenName = user.ScreenName;
post.Nickname = user.Name.Trim();
post.ImageUrl = user.ProfileImageUrl;
post.IsProtect = user.Protected;
// Retweetした人
post.RetweetedBy = status.User.ScreenName;
post.IsMe = post.RetweetedBy.ToLower().Equals(_uname);
}
else
{
post.CreatedAt = MyCommon.DateTimeParse(status.CreatedAt);
// 本文
post.TextFromApi = status.Text;
entities = status.Entities;
// Source取得（htmlの場合は、中身を取り出し）
post.Source = status.Source;
{
long t;
long.TryParse(status.InReplyToStatusId, out t);
post.InReplyToStatusId = t;
}
post.InReplyToUser = status.InReplyToScreenName;
{
long t;
long.TryParse(status.InReplyToUserId, out t);
post.InReplyToUserId = t;
}
post.IsFav = true;
// 以下、ユーザー情報
var user = status.User;
post.UserId = user.Id;
post.ScreenName = user.ScreenName;
post.Nickname = user.Name.Trim();
post.ImageUrl = user.ProfileImageUrl;
post.IsProtect = user.Protected;
post.IsMe = post.ScreenName.ToLower().Equals(_uname);
}
// HTMLに整形
{
var t = post.TextFromApi;
post.Text = CreateHtmlAnchor(ref t, post.ReplyToList, entities, post.Media);
post.TextFromApi = t;
}
post.TextFromApi = ReplaceTextFromApi(post.TextFromApi, entities);
post.TextFromApi = HttpUtility.HtmlDecode(post.TextFromApi);
post.TextFromApi = post.TextFromApi.Replace("<3", "♡");
CreateSource(ref post); // Source整形
post.IsRead = read;
post.IsReply = post.ReplyToList.Contains(_uname);
post.IsExcludeReply = false;
if (post.IsMe)
{
post.IsOwl = false;
}
else
{
if (_followerIds.Count > 0)
{
post.IsOwl = !_followerIds.Contains(post.UserId);
}
}
post.IsDm = false;
}
catch (Exception ex)
{
MyCommon.TraceOut(ex, MethodBase.GetCurrentMethod().Name + " " + content);
continue;
}
TabInformations.Instance.AddPost(post);
}
return string.Empty;
}
